// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package ast

import (

"fmt"

"iter"

)

// A Visitor's Visit method is invoked for each node encountered by [Walk].

// If the result visitor w is not nil, [Walk] visits each of the children

// of node with the visitor w, followed by a call of w.Visit(nil).

type Visitor interface {

Visit(node Node) (w Visitor)

}

func walkList[N Node](v Visitor, list []N) {

}

// TODO(gri): Investigate if providing a closure to Walk leads to

// simpler use (and may help eliminate Inspect in turn).

// Walk traverses an AST in depth-first order: It starts by calling

// v.Visit(node); node must not be nil. If the visitor w returned by

// v.Visit(node) is not nil, Walk is invoked recursively with visitor

// w for each of the non-nil children of node, followed by a call of

// w.Visit(nil).

func Walk(v Visitor, node Node) {

}

type inspector func(Node) bool

func (f inspector) Visit(node Node) Visitor {

}

// Inspect traverses an AST in depth-first order: It starts by calling

// f(node); node must not be nil. If f returns true, Inspect invokes f

// recursively for each of the non-nil children of node, followed by a

// call of f(nil).

func Inspect(node Node, f func(Node) bool) {

Walk(inspector(f), node)

}

// Preorder returns an iterator over all the nodes of the syntax tree

// beneath (and including) the specified root, in depth-first

// preorder.

//

// For greater control over the traversal of each subtree, use [Inspect].

func Preorder(root Node) iter.Seq[Node] {

}