public static int GetFirstChildIndexSpanningPosition(SyntaxNode node, int position)
{
if (!node.FullSpan.IntersectsWith(position))
{
throw new ArgumentException("Must be within node's FullSpan", nameof(position));
}
return(GetFirstChildIndexSpanningPosition(node.ChildNodesAndTokens(), position));
}
private static void GetDirectives <TDirective>(SyntaxNode node, Func <TDirective, bool> filter, ref List <TDirective> directives)
where TDirective : SyntaxNode
{
if (node.ContainsDirectives)
{
foreach (SyntaxNodeOrToken child in node.ChildNodesAndTokens())
{
GetDirectives(child, filter, ref directives);
}
}
}
public SyntaxNodeOrToken GetNextSibling()
{
SyntaxNode parent = this.Parent;
if (parent == null)
{
return(default(SyntaxNodeOrToken));
}
ChildSyntaxList siblings = parent.ChildNodesAndTokens();
return(siblings.Count < 8
? GetNextSiblingFromStart(siblings)
: GetNextSiblingWithSearch(siblings));
}
internal SyntaxToken GetLastToken(SyntaxNode current, Func <SyntaxToken, bool> predicate, Func <SyntaxTrivia, bool> stepInto)
{
foreach (var child in current.ChildNodesAndTokens().Reverse())
{
var token = child.IsToken
? GetLastToken(child.AsToken(), predicate, stepInto)
: GetLastToken(child.AsNode(), predicate, stepInto);
if (token.RawKind != None)
{
return(token);
}
}
return(default(SyntaxToken));
}
internal SyntaxToken GetLastToken(SyntaxNode current, Func<SyntaxToken, bool> predicate, Func<SyntaxTrivia, bool> stepInto)
{
foreach (var child in current.ChildNodesAndTokens().Reverse())
{
var token = child.IsToken
? GetLastToken(child.AsToken(), predicate, stepInto)
: GetLastToken(child.AsNode(), predicate, stepInto);
if (token.RawKind != None)
{
return token;
}
}
return default(SyntaxToken);
}
internal SyntaxToken GetLastToken(SyntaxNode current, Func <SyntaxToken, bool> predicate, Func <SyntaxTrivia, bool> stepInto)
{
var stack = s_childReversedEnumeratorStackPool.Allocate();
try
{
stack.Push(current.ChildNodesAndTokens().Reverse().GetEnumerator());
while (stack.Count > 0)
{
var en = stack.Pop();
if (en.MoveNext())
{
var child = en.Current;
if (child.IsToken)
{
var token = GetLastToken(child.AsToken(), predicate, stepInto);
if (token.RawKind != None)
{
return(token);
}
}
// push this enumerator back, not done yet
stack.Push(en);
if (child.IsNode)
{
stack.Push(child.AsNode().ChildNodesAndTokens().Reverse().GetEnumerator());
}
}
}
return(default(SyntaxToken));
}
finally
{
stack.Clear();
s_childReversedEnumeratorStackPool.Free(stack);
}
}
/// <summary>
/// Called when the walker visits a node. This method may be overridden if subclasses want
/// to handle the node. Overrides should call back into this base method if they want the
/// children of this node to be visited.
/// </summary>
/// <param name="node">The current node that the walker is visiting.</param>
public virtual void Visit(SyntaxNode node)
{
foreach (var child in node.ChildNodesAndTokens())
{
if (child.IsNode)
{
if (this.Depth >= SyntaxWalkerDepth.Node)
{
Visit(child.AsNode());
}
}
else if (child.IsToken)
{
if (this.Depth >= SyntaxWalkerDepth.Token)
{
VisitToken(child.AsToken());
}
}
}
}
/// <summary>
/// Called when the walker visits a node. This method may be overridden if subclasses want
/// to handle the node. Overrides should call back into this base method if they want the
/// children of this node to be visited.
/// </summary>
/// <param name="node">The current node that the walker is visiting.</param>
public virtual void Visit(SyntaxNode node)
{
foreach (var child in node.ChildNodesAndTokens())
{
if (child.IsNode)
{
if (this.Depth >= SyntaxWalkerDepth.Node)
{
Visit(child.AsNode());
}
}
else if (child.IsToken)
{
if (this.Depth >= SyntaxWalkerDepth.Token)
{
VisitToken(child.AsToken());
}
}
}
}
internal SyntaxToken GetFirstToken(SyntaxNode current, Func<SyntaxToken, bool> predicate, Func<SyntaxTrivia, bool> stepInto)
{
var stack = s_childEnumeratorStackPool.Allocate();
try
{
stack.Push(current.ChildNodesAndTokens().GetEnumerator());
while (stack.Count > 0)
{
var en = stack.Pop();
if (en.MoveNext())
{
var child = en.Current;
if (child.IsToken)
{
var token = GetFirstToken(child.AsToken(), predicate, stepInto);
if (token.RawKind != None)
{
return token;
}
}
// push this enumerator back, not done yet
stack.Push(en);
if (child.IsNode)
{
stack.Push(child.AsNode().ChildNodesAndTokens().GetEnumerator());
}
}
}
return default(SyntaxToken);
}
finally
{
stack.Clear();
s_childEnumeratorStackPool.Free(stack);
}
}
private static SymbolKeyResolution?Resolve(
SemanticModel semanticModel, SyntaxNode syntaxNode, string name, ISymbol target,
CancellationToken cancellationToken)
{
var symbol = semanticModel.GetDeclaredSymbol(syntaxNode, cancellationToken);
if (symbol != null)
{
if (symbol.Kind == SymbolKind.Alias)
{
var aliasSymbol = (IAliasSymbol)symbol;
if (aliasSymbol.Name == name &&
SymbolEquivalenceComparer.Instance.Equals(aliasSymbol.Target, target))
{
return(new SymbolKeyResolution(aliasSymbol));
}
}
else if (symbol.Kind != SymbolKind.Namespace)
{
// Don't recurse into anything except namespaces. We can't find aliases
// any deeper than that.
return(null);
}
}
foreach (var child in syntaxNode.ChildNodesAndTokens())
{
if (child.IsNode)
{
var result = Resolve(semanticModel, child.AsNode(), name, target, cancellationToken);
if (result.HasValue)
{
return(result);
}
}
}
return(null);
}
private static SymbolKeyResolution? Resolve(
SemanticModel semanticModel, SyntaxNode syntaxNode, string name, ISymbol target,
CancellationToken cancellationToken)
{
var symbol = semanticModel.GetDeclaredSymbol(syntaxNode, cancellationToken);
if (symbol != null)
{
if (symbol.Kind == SymbolKind.Alias)
{
var aliasSymbol = (IAliasSymbol)symbol;
if (aliasSymbol.Name == name &&
SymbolEquivalenceComparer.Instance.Equals(aliasSymbol.Target, target))
{
return new SymbolKeyResolution(aliasSymbol);
}
}
else if (symbol.Kind != SymbolKind.Namespace)
{
// Don't recurse into anything except namespaces. We can't find aliases
// any deeper than that.
return null;
}
}
foreach (var child in syntaxNode.ChildNodesAndTokens())
{
if (child.IsNode)
{
var result = Resolve(semanticModel, child.AsNode(), name, target, cancellationToken);
if (result.HasValue)
{
return result;
}
}
}
return null;
}
private void AddNode(TreeViewItem parentItem, SyntaxNode node)
{
var kind = node.GetKind();
var tag = new SyntaxTag()
{
SyntaxNode = node,
Category = SyntaxCategory.SyntaxNode,
Span = node.Span,
FullSpan = node.FullSpan,
Kind = kind,
ParentItem = parentItem
};
var item = new TreeViewItem()
{
Tag = tag,
IsExpanded = false,
Foreground = Brushes.Blue,
Background = node.ContainsDiagnostics ? Brushes.Pink : Brushes.White,
Header = tag.Kind + " " + node.Span.ToString()
};
if (SyntaxTree != null && node.ContainsDiagnostics)
{
item.ToolTip = string.Empty;
foreach (var diagnostic in SyntaxTree.GetDiagnostics(node))
{
item.ToolTip += diagnostic.ToString() + "\n";
}
item.ToolTip = item.ToolTip.ToString().Trim();
}
item.Selected += new RoutedEventHandler((sender, e) =>
{
_isNavigatingFromTreeToSource = true;
typeTextLabel.Visibility = Visibility.Visible;
kindTextLabel.Visibility = Visibility.Visible;
typeValueLabel.Content = node.GetType().Name;
kindValueLabel.Content = kind;
_propertyGrid.SelectedObject = node;
item.IsExpanded = true;
if (!_isNavigatingFromSourceToTree && SyntaxNodeNavigationToSourceRequested != null)
{
SyntaxNodeNavigationToSourceRequested(node);
}
_isNavigatingFromTreeToSource = false;
e.Handled = true;
});
item.Expanded += new RoutedEventHandler((sender, e) =>
{
if (item.Items.Count == 1 && item.Items[0] == null)
{
// Remove placeholder child and populate real children.
item.Items.RemoveAt(0);
foreach (var child in node.ChildNodesAndTokens())
{
AddNodeOrToken(item, child);
}
}
});
if (parentItem == null)
{
treeView.Items.Clear();
treeView.Items.Add(item);
}
else
{
parentItem.Items.Add(item);
}
if (node.ChildNodesAndTokens().Count > 0)
{
if (IsLazy)
{
// Add placeholder child to indicate that real children need to be populated on expansion.
item.Items.Add(null);
}
else
{
// Recursively populate all descendants.
foreach (var child in node.ChildNodesAndTokens())
{
AddNodeOrToken(item, child);
}
}
}
}
/// <summary>
/// The list of child nodes and tokens of the underlying node or token.
/// </summary>
public ChildSyntaxList ChildNodesAndTokens()
{
return(this.IsToken
? default(ChildSyntaxList)
: _nodeOrParent.ChildNodesAndTokens());
}
void VisitBody (SyntaxNode node)
{
var oldIter = curIter;
foreach (var syntaxNodeOrToken in node.ChildNodesAndTokens ()) {
var syntaxNode = syntaxNodeOrToken.AsNode ();
if (syntaxNode != null) {
Visit (syntaxNode);
} else {
var syntaxToken = syntaxNodeOrToken.AsToken ();
if (syntaxToken.Kind () == SyntaxKind.OpenBraceToken)
curIter = Append (node);
VisitToken (syntaxToken);
}
}
curIter = oldIter;
}
private void GetAllSymbols(SemanticModel model, SyntaxNode node, List<ISymbol> list)
{
var symbol = model.GetDeclaredSymbol(node);
if (symbol != null)
{
list.Add(symbol);
}
symbol = model.GetSymbolInfo(node).GetAnySymbol();
if (symbol != null)
{
list.Add(symbol);
}
foreach (var child in node.ChildNodesAndTokens())
{
if (child.IsNode)
{
GetAllSymbols(model, child.AsNode(), list);
}
}
}
