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()); } } } }
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); } } }