Manually Navigating a Syntax Tree
Manually walking a syntax tree is the lowest level means of navigation, and involves walking the nodes using the properties defined on
Walking up the tree
You can walk up the tree using the
Parent property. This is very useful for finding the context that the current node is in - for example, you can walk the
Parent property of a method invocation to see if the invocation is happening inside a method declaration that is async or not.
To walk the
Parent property, you will want to write code like this:
Walking sibling nodes
Since a file is parsed into a tree structure, nodes have siblings as well as children. For example, a C# file can have a class declaration that contains multiple methods. Each method is represented by an
IMethodDeclaration node. Intuitively, each method is a child of the class, and therefore are siblings, and no method is higher or lower in the tree than any other.
You can walk the siblings with code like this:
Obviously the code to walk the sibling chain in reverse is just the same, but using the
Walking down the tree
Walking down the tree is very similar to walking the sibling chain. Again, since this is a tree structure a single node can have multiple children. For example, a C# file's list of
using statements is represented by an
IUsingList node, and this will have multiple children - multiple instances of
IUsingNamespaceDirective (with each child again separated by whitespace nodes).
To walk the immediate children of a node, you'll want to write code like this:
Note that we start with
FirstChild but then walk that child's siblings. To walk the children in reverse order, start with
LastChild, and walk
If you want to walk all descendants of a node, simply recursively walk a child node's children.