parser

type ArrayLit struct {
	Exprs []Expr
	L     loc.Loc
}

type ArrayType struct {
	ElemType Type
	L        loc.Loc
}

type BlockLit struct {
	Parms []FuncParm
	Exprs []Expr
	L     loc.Loc
}

type Call struct {
	Fun  Expr
	Args []Expr
	L    loc.Loc
}

type CaseDef struct {
	Name Ident
	Type Type // nil if an un-typed case
	L    loc.Loc
}

type CaseVal struct {
	Name Ident
	Val  Expr // nil if value-less case
	L    loc.Loc
}

type CharLit struct {
	Source string // source text
	Rune   rune
	L      loc.Loc
}

type Comment struct {
	Text string
	L    loc.Loc
}

type Convert struct {
	Type Type
	Expr Expr
	L    loc.Loc
}

type Def interface{}

type Expr interface {
	Loc() loc.Loc
}

type FieldDef struct {
	Name Ident
	Type Type
	L    loc.Loc
}

type FieldVal struct {
	Name Ident
	Val  Expr
	L    loc.Loc
}

type File struct {
	Imports []*Import
	Defs    []Def
	// All comments sorted by their start location.
	Comments []Comment

	P      string
	NLs    []int
	Length int
}

type FloatLit struct {
	Text string
	L    loc.Loc
}

type FuncDecl struct {
	Name  Ident
	Parms []Type
	Ret   Type // nil if no return
	L     loc.Loc
}

type FuncDef struct {
	Exp   bool
	Name  Ident
	Parms []FuncParm
	Ret   Type // nil if no return
	// Constraints is an interface constraint to satisfy
	// after the return type is determined.
	// Each element is either a *FuncDecl
	// or a *NamedType naming an interface.
	Constraints []interface{}
	Exprs       []Expr // nil if unspecified, non-nil, len()==0 if empty
	L           loc.Loc
}

type FuncParm struct {
	Name Ident
	Type Type
	// Constraints is an interface constraint to satisfy
	// after this parameter type is determined.
	// Each element is either a *FuncDecl
	// or a *NamedType naming an interface.
	Constraints []interface{}
	L           loc.Loc
}

type FuncType struct {
	Parms []Type
	Ret   Type // nil if no return
	L     loc.Loc
}

type Ident struct {
	Name string

	// Parts contains elements of Name,
	// if it was composed of multiple
	// colon words or question words.
	Parts []Ident

	// L is the location spanning the entire identifier.
	L loc.Loc
}

type IfaceDef struct {
	Exp       bool
	Opaque    bool
	TypeParms []TypeVar
	Name      Ident
	// Iface and Alias are mutually exclusive.
	// Iface is the defintition of a non-alias interface.
	// Each element is either a *FuncDecl
	// or a *NamedType naming an interface.
	Iface []interface{}
	// Alias is the name of an interface that this one aliases.
	Alias *NamedType
	L     loc.Loc
}

type Import struct {
	Exp  bool
	Name *Ident // nil if unspecified
	Path string
	L    loc.Loc
}

type IntLit struct {
	Text string
	L    loc.Loc
}

type ModSel struct {
	Mod  Ident
	Name Ident
	L    loc.Loc
}

type NamedType struct {
	Args []Type
	Mod  *Ident // nil if unspecified
	Name Ident
	L    loc.Loc
}

type Parser struct {
	Files []*File
	// TrimErrorPathPrefix is trimmed from path names
	// in parse error messages.
	TrimErrorPathPrefix string
	// contains filtered or unexported fields
}

type PrintOpt func(*config)

type RefType struct {
	Type Type
	L    loc.Loc
}

type StrLit struct {
	Raw    bool
	Source string // source text
	Data   string
	L      loc.Loc
}

type StructLit struct {
	FieldVals []FieldVal
	L         loc.Loc
}

type StructType struct {
	Fields []FieldDef
	L      loc.Loc
}

type SubExpr struct {
	Expr
	L loc.Loc
}

type TestDef struct {
	Name  Ident
	Exprs []Expr
	L     loc.Loc
}

type Type interface {
	Loc() loc.Loc
}

type TypeDef struct {
	Exp       bool
	Opaque    bool
	Alias     bool
	TypeParms []TypeVar
	Name      Ident
	Type      Type
	L         loc.Loc
}

type TypeVar struct {
	Name string
	L    loc.Loc
}

type UnionLit struct {
	CaseVal CaseVal
	L       loc.Loc
}

type UnionType struct {
	Cases []CaseDef
	L     loc.Loc
}

type VarDef struct {
	Exp   bool
	Const bool
	Name  Ident
	Type  Type
	Expr  Expr // nil if unspecified
	L     loc.Loc
}