paths

func Dereference ¶

func Dereference(root ast.Node, path protopath.Path) ast.Node

Dereference walks the given path from the root node and returns the node at the end of the path.

func DereferenceAll ¶

func DereferenceAll(root ast.Node, path protopath.Path) []ast.Node

DereferenceAll walks the given path from the root node and returns all nodes visited. The first node in the returned slice is the root node. Not all path steps reference an actual node in the AST, so the returned slice may contain fewer than len(path) nodes.

func Join ¶

func Join[T protopath.Step, S ~[]T](a protopath.Path, b S) protopath.Path

Join returns a new path constructed by appending the steps of 'b' to 'a'. The first step in 'b' is skipped; it is assumed (but not checked for) that 'b' starts with a Root step matching the message type of the last step in path 'a'.

func NodeAt ¶

func NodeAt[T ast.Node](idx PathIndex) (t T)

NodeAt returns the node at the given index in a path.

func NodeIsConcrete ¶

func NodeIsConcrete(values protopath.Values, index int) bool

NodeIsConcrete returns true if the value at the given index in 'values' is a concrete node value, and false otherwise. A concrete node is a message that is not a wrapper node (or an array access to a wrapper node), and is not a list or map.

func NodeView ¶

func NodeView(in func(v ast.Node)) func(v protopath.Values) error

NodeView returns a visitor suitable for use with ast.WithBefore and ast.WithAfter which calls the given function for each concrete node value encountered, ignoring wrapper nodes and other non-node values.

func Slice ¶

func Slice(from protopath.Values, start, end int) protopath.Values

Slice returns a new path with both its path and values resliced by the given range. It is assumed that both slices are of the same length.

func Suffix2 ¶

func Suffix2[T, U ast.Node](values protopath.Values) (
	out struct {
		T      T
		TIndex int
		U      U
		UIndex int
	},
	ok bool,
)

Suffix2 inspects the given values and, if the path logically ends with the sequence of nodes 'T, U' (such that U is a message field of T), returns the two nodes and true. Otherwise, returns false. This method correctly handles non-node path steps such as list accesses. The returned nodes may not necessarily be the final 2 nodes in the path.

func Suffix3 ¶

func Suffix3[T, U, V ast.Node](values protopath.Values) (
	out struct {
		T      T
		TIndex int
		U      U
		UIndex int
		V      V
		VIndex int
	},
	ok bool,
)

func Suffix4 ¶

func Suffix4[T, U, V, W ast.Node](values protopath.Values) (
	out struct {
		T      T
		TIndex int
		U      U
		UIndex int
		V      V
		VIndex int
		W      W
		WIndex int
	},
	ok bool,
)

func Suffix5 ¶

func Suffix5[T, U, V, W, X ast.Node](values protopath.Values) (
	out struct {
		T      T
		TIndex int
		U      U
		UIndex int
		V      V
		VIndex int
		W      W
		WIndex int
		X      X
		XIndex int
	},
	ok bool,
)

func ValuesToNodes ¶

func ValuesToNodes(values protopath.Values) (nodes []ast.Node)

ValuesToNodes returns a slice of nodes from the given values, filtering out wrapper nodes and other non-node values from the path.