declarationfacts

type Container[N comparable] struct {
	Name string
	Node N
}

type ContainerRule struct {
	NodeType, NameField, NameNodeType, TypeField string
	Ancestors, ParentPath                        []string
	BodyWrappers                                 []TypeNameRule
	// Self makes the node passed to Containers the owner itself, rather than a
	// body owned by it. TypeField is then optional and unused.
	Self bool
}

type Fact struct {
	Lang, Kind, Name, NodeType                     string
	StartByte, EndByte, NameStartByte, NameEndByte uint32
	Shape                                          string `json:",omitempty"`
	Container                                      string `json:",omitempty"`
	ContainerStartByte                             uint32 `json:",omitempty"`
	ContainerEndByte                               uint32 `json:",omitempty"`
	Embedded                                       bool   `json:",omitempty"`
}

type Grammar struct {
	Names  []string
	Symbol func(string) (uint16, bool)
	Field  func(string) (uint16, bool)
}

type Names[N comparable] struct {
	// contains filtered or unexported fields
}

type Program[N comparable] struct {
	// contains filtered or unexported fields
}

type Reader[N comparable] struct {
	Language           string
	Symbol             func(N) uint16
	Parent             func(N) N
	ChildCount         func(N) int
	Child              func(N, int) N
	Field              func(N, int) uint16
	Missing            func(N) bool
	Named              func(N) bool
	Text               func(N, []byte) string
	NodeType           func(N) string
	StartByte, EndByte func(N) uint32
}

type Rule struct {
	NodeType, Kind, NameField, NameNodeType                       string
	Ancestors                                                     []string
	TypeField, TypeNodeType, Shape                                string
	ContainerNameField, ContainerNameNodeType, ContainerTypeField string
	// BaseName selects an embedded type through TypeNames; BaseNameField is
	// empty for a node with one named child. A non-empty BaseNameField emits one
	// fact for every direct child in that field. ExcludeNames filters bare constraint terms.
	BaseName      bool
	BaseNameField string
	Embedded      bool
	ExcludeNames  []string
	TypeNames     []TypeNameRule
	// ContainerPath replaces fixed container ownership with recursive exact paths.
	ContainerPath []ContainerRule
	// ParentChildField and ParentChildNodeType, set together, require the direct
	// parent to have a direct child in that field with that node type. They
	// separate declarations that share a parent node type, such as a keyword token.
	ParentChildField, ParentChildNodeType string
	// NameSelf makes the matched node its own name; NameNodeType must equal
	// NodeType and NameField stays empty. Its name range is the node range.
	NameSelf bool
	// NameWrappers holds binding patterns; only names reached through these wrappers emit facts.
	NameWrappers []string
}

type SymbolSet map[uint16]bool

type TypeNameRule struct {
	NodeType, Field string
	Leaf            bool
}