mirror of https://github.com/icsharpcode/ILSpy.git
Andreas Weizel
7 years ago
9 changed files with 1027 additions and 38 deletions
@ -0,0 +1,821 @@ |
|||||||
|
using System; |
||||||
|
using System.Collections.Generic; |
||||||
|
using System.Diagnostics; |
||||||
|
using System.Linq; |
||||||
|
using System.Threading; |
||||||
|
using Microsoft.CodeAnalysis.CSharp.Syntax; |
||||||
|
using Microsoft.CodeAnalysis.Shared.Extensions; |
||||||
|
using Microsoft.CodeAnalysis.Text; |
||||||
|
using Roslyn.Utilities; |
||||||
|
using Microsoft.CodeAnalysis; |
||||||
|
using Microsoft.CodeAnalysis.CSharp; |
||||||
|
using System.Threading.Tasks; |
||||||
|
|
||||||
|
namespace ICSharpCode.ILSpy.AddIn |
||||||
|
{ |
||||||
|
static class SyntaxNodeExtensions |
||||||
|
{ |
||||||
|
public static IEnumerable<SyntaxNode> GetAncestors(this SyntaxNode node) |
||||||
|
{ |
||||||
|
var current = node.Parent; |
||||||
|
|
||||||
|
while (current != null) |
||||||
|
{ |
||||||
|
yield return current; |
||||||
|
|
||||||
|
current = current is IStructuredTriviaSyntax |
||||||
|
? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent |
||||||
|
: current.Parent; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public static IEnumerable<TNode> GetAncestors<TNode>(this SyntaxNode node) |
||||||
|
where TNode : SyntaxNode |
||||||
|
{ |
||||||
|
var current = node.Parent; |
||||||
|
while (current != null) |
||||||
|
{ |
||||||
|
if (current is TNode) |
||||||
|
{ |
||||||
|
yield return (TNode)current; |
||||||
|
} |
||||||
|
|
||||||
|
current = current is IStructuredTriviaSyntax |
||||||
|
? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent |
||||||
|
: current.Parent; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public static TNode GetAncestor<TNode>(this SyntaxNode node) |
||||||
|
where TNode : SyntaxNode |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return default(TNode); |
||||||
|
} |
||||||
|
|
||||||
|
return node.GetAncestors<TNode>().FirstOrDefault(); |
||||||
|
} |
||||||
|
|
||||||
|
public static TNode GetAncestorOrThis<TNode>(this SyntaxNode node) |
||||||
|
where TNode : SyntaxNode |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return default(TNode); |
||||||
|
} |
||||||
|
|
||||||
|
return node.GetAncestorsOrThis<TNode>().FirstOrDefault(); |
||||||
|
} |
||||||
|
|
||||||
|
public static IEnumerable<TNode> GetAncestorsOrThis<TNode>(this SyntaxNode node) |
||||||
|
where TNode : SyntaxNode |
||||||
|
{ |
||||||
|
var current = node; |
||||||
|
while (current != null) |
||||||
|
{ |
||||||
|
if (current is TNode) |
||||||
|
{ |
||||||
|
yield return (TNode)current; |
||||||
|
} |
||||||
|
|
||||||
|
current = current is IStructuredTriviaSyntax |
||||||
|
? ((IStructuredTriviaSyntax)current).ParentTrivia.Token.Parent |
||||||
|
: current.Parent; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public static bool HasAncestor<TNode>(this SyntaxNode node) |
||||||
|
where TNode : SyntaxNode |
||||||
|
{ |
||||||
|
return node.GetAncestors<TNode>().Any(); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool CheckParent<T>(this SyntaxNode node, Func<T, bool> valueChecker) where T : SyntaxNode |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var parentNode = node.Parent as T; |
||||||
|
if (parentNode == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
return valueChecker(parentNode); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns true if is a given token is a child token of of a certain type of parent node.
|
||||||
|
/// </summary>
|
||||||
|
/// <typeparam name="TParent">The type of the parent node.</typeparam>
|
||||||
|
/// <param name="node">The node that we are testing.</param>
|
||||||
|
/// <param name="childGetter">A function that, when given the parent node, returns the child token we are interested in.</param>
|
||||||
|
public static bool IsChildNode<TParent>(this SyntaxNode node, Func<TParent, SyntaxNode> childGetter) |
||||||
|
where TParent : SyntaxNode |
||||||
|
{ |
||||||
|
var ancestor = node.GetAncestor<TParent>(); |
||||||
|
if (ancestor == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var ancestorNode = childGetter(ancestor); |
||||||
|
|
||||||
|
return node == ancestorNode; |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns true if this node is found underneath the specified child in the given parent.
|
||||||
|
/// </summary>
|
||||||
|
public static bool IsFoundUnder<TParent>(this SyntaxNode node, Func<TParent, SyntaxNode> childGetter) |
||||||
|
where TParent : SyntaxNode |
||||||
|
{ |
||||||
|
var ancestor = node.GetAncestor<TParent>(); |
||||||
|
if (ancestor == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var child = childGetter(ancestor); |
||||||
|
|
||||||
|
// See if node passes through child on the way up to ancestor.
|
||||||
|
return node.GetAncestorsOrThis<SyntaxNode>().Contains(child); |
||||||
|
} |
||||||
|
|
||||||
|
public static SyntaxNode GetCommonRoot(this SyntaxNode node1, SyntaxNode node2) |
||||||
|
{ |
||||||
|
//Contract.ThrowIfTrue(node1.RawKind == 0 || node2.RawKind == 0);
|
||||||
|
|
||||||
|
// find common starting node from two nodes.
|
||||||
|
// as long as two nodes belong to same tree, there must be at least one common root (Ex, compilation unit)
|
||||||
|
var ancestors = node1.GetAncestorsOrThis<SyntaxNode>(); |
||||||
|
var set = new HashSet<SyntaxNode>(node2.GetAncestorsOrThis<SyntaxNode>()); |
||||||
|
|
||||||
|
return ancestors.First(set.Contains); |
||||||
|
} |
||||||
|
|
||||||
|
public static int Width(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.Span.Length; |
||||||
|
} |
||||||
|
|
||||||
|
public static int FullWidth(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.FullSpan.Length; |
||||||
|
} |
||||||
|
|
||||||
|
public static SyntaxNode FindInnermostCommonNode( |
||||||
|
this IEnumerable<SyntaxNode> nodes, |
||||||
|
Func<SyntaxNode, bool> predicate) |
||||||
|
{ |
||||||
|
IEnumerable<SyntaxNode> blocks = null; |
||||||
|
foreach (var node in nodes) |
||||||
|
{ |
||||||
|
blocks = blocks == null |
||||||
|
? node.AncestorsAndSelf().Where(predicate) |
||||||
|
: blocks.Intersect(node.AncestorsAndSelf().Where(predicate)); |
||||||
|
} |
||||||
|
|
||||||
|
return blocks == null ? null : blocks.First(); |
||||||
|
} |
||||||
|
|
||||||
|
public static TSyntaxNode FindInnermostCommonNode<TSyntaxNode>(this IEnumerable<SyntaxNode> nodes) |
||||||
|
where TSyntaxNode : SyntaxNode |
||||||
|
{ |
||||||
|
return (TSyntaxNode)nodes.FindInnermostCommonNode(n => n is TSyntaxNode); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// create a new root node from the given root after adding annotations to the tokens
|
||||||
|
///
|
||||||
|
/// tokens should belong to the given root
|
||||||
|
/// </summary>
|
||||||
|
public static SyntaxNode AddAnnotations(this SyntaxNode root, IEnumerable<Tuple<SyntaxToken, SyntaxAnnotation>> pairs) |
||||||
|
{ |
||||||
|
// Contract.ThrowIfNull(root);
|
||||||
|
// Contract.ThrowIfNull(pairs);
|
||||||
|
|
||||||
|
var tokenMap = pairs.GroupBy(p => p.Item1, p => p.Item2).ToDictionary(g => g.Key, g => g.ToArray()); |
||||||
|
return root.ReplaceTokens(tokenMap.Keys, (o, n) => o.WithAdditionalAnnotations(tokenMap[o])); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// create a new root node from the given root after adding annotations to the nodes
|
||||||
|
///
|
||||||
|
/// nodes should belong to the given root
|
||||||
|
/// </summary>
|
||||||
|
public static SyntaxNode AddAnnotations(this SyntaxNode root, IEnumerable<Tuple<SyntaxNode, SyntaxAnnotation>> pairs) |
||||||
|
{ |
||||||
|
// Contract.ThrowIfNull(root);
|
||||||
|
// Contract.ThrowIfNull(pairs);
|
||||||
|
|
||||||
|
var tokenMap = pairs.GroupBy(p => p.Item1, p => p.Item2).ToDictionary(g => g.Key, g => g.ToArray()); |
||||||
|
return root.ReplaceNodes(tokenMap.Keys, (o, n) => o.WithAdditionalAnnotations(tokenMap[o])); |
||||||
|
} |
||||||
|
|
||||||
|
public static TextSpan GetContainedSpan(this IEnumerable<SyntaxNode> nodes) |
||||||
|
{ |
||||||
|
// Contract.ThrowIfNull(nodes);
|
||||||
|
// Contract.ThrowIfFalse(nodes.Any());
|
||||||
|
|
||||||
|
TextSpan fullSpan = nodes.First().Span; |
||||||
|
foreach (var node in nodes) |
||||||
|
{ |
||||||
|
fullSpan = TextSpan.FromBounds( |
||||||
|
Math.Min(fullSpan.Start, node.SpanStart), |
||||||
|
Math.Max(fullSpan.End, node.Span.End)); |
||||||
|
} |
||||||
|
|
||||||
|
return fullSpan; |
||||||
|
} |
||||||
|
|
||||||
|
public static IEnumerable<TextSpan> GetContiguousSpans( |
||||||
|
this IEnumerable<SyntaxNode> nodes, Func<SyntaxNode, SyntaxToken> getLastToken = null) |
||||||
|
{ |
||||||
|
SyntaxNode lastNode = null; |
||||||
|
TextSpan? textSpan = null; |
||||||
|
foreach (var node in nodes) |
||||||
|
{ |
||||||
|
if (lastNode == null) |
||||||
|
{ |
||||||
|
textSpan = node.Span; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
var lastToken = getLastToken == null |
||||||
|
? lastNode.GetLastToken() |
||||||
|
: getLastToken(lastNode); |
||||||
|
if (lastToken.GetNextToken(includeDirectives: true) == node.GetFirstToken()) |
||||||
|
{ |
||||||
|
// Expand the span
|
||||||
|
textSpan = TextSpan.FromBounds(textSpan.Value.Start, node.Span.End); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
// Return the last span, and start a new one
|
||||||
|
yield return textSpan.Value; |
||||||
|
textSpan = node.Span; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
lastNode = node; |
||||||
|
} |
||||||
|
|
||||||
|
if (textSpan.HasValue) |
||||||
|
{ |
||||||
|
yield return textSpan.Value; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
//public static bool OverlapsHiddenPosition(this SyntaxNode node, CancellationToken cancellationToken)
|
||||||
|
//{
|
||||||
|
// return node.OverlapsHiddenPosition(node.Span, cancellationToken);
|
||||||
|
//}
|
||||||
|
|
||||||
|
//public static bool OverlapsHiddenPosition(this SyntaxNode node, TextSpan span, CancellationToken cancellationToken)
|
||||||
|
//{
|
||||||
|
// return node.SyntaxTree.OverlapsHiddenPosition(span, cancellationToken);
|
||||||
|
//}
|
||||||
|
|
||||||
|
//public static bool OverlapsHiddenPosition(this SyntaxNode declaration, SyntaxNode startNode, SyntaxNode endNode, CancellationToken cancellationToken)
|
||||||
|
//{
|
||||||
|
// var start = startNode.Span.End;
|
||||||
|
// var end = endNode.SpanStart;
|
||||||
|
|
||||||
|
// var textSpan = TextSpan.FromBounds(start, end);
|
||||||
|
// return declaration.OverlapsHiddenPosition(textSpan, cancellationToken);
|
||||||
|
//}
|
||||||
|
|
||||||
|
public static IEnumerable<T> GetAnnotatedNodes<T>(this SyntaxNode node, SyntaxAnnotation syntaxAnnotation) where T : SyntaxNode |
||||||
|
{ |
||||||
|
return node.GetAnnotatedNodesAndTokens(syntaxAnnotation).Select(n => n.AsNode()).OfType<T>(); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2) |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var csharpKind = node.Kind(); |
||||||
|
return csharpKind == kind1 || csharpKind == kind2; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3) |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var csharpKind = node.Kind(); |
||||||
|
return csharpKind == kind1 || csharpKind == kind2 || csharpKind == kind3; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3, SyntaxKind kind4) |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var csharpKind = node.Kind(); |
||||||
|
return csharpKind == kind1 || csharpKind == kind2 || csharpKind == kind3 || csharpKind == kind4; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsKind(this SyntaxNode node, SyntaxKind kind1, SyntaxKind kind2, SyntaxKind kind3, SyntaxKind kind4, SyntaxKind kind5) |
||||||
|
{ |
||||||
|
if (node == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var csharpKind = node.Kind(); |
||||||
|
return csharpKind == kind1 || csharpKind == kind2 || csharpKind == kind3 || csharpKind == kind4 || csharpKind == kind5; |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns the list of using directives that affect <paramref name="node"/>. The list will be returned in
|
||||||
|
/// top down order.
|
||||||
|
/// </summary>
|
||||||
|
public static IEnumerable<UsingDirectiveSyntax> GetEnclosingUsingDirectives(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.GetAncestorOrThis<CompilationUnitSyntax>().Usings |
||||||
|
.Concat(node.GetAncestorsOrThis<NamespaceDeclarationSyntax>() |
||||||
|
.Reverse() |
||||||
|
.SelectMany(n => n.Usings)); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsUnsafeContext(this SyntaxNode node) |
||||||
|
{ |
||||||
|
if (node.GetAncestor<UnsafeStatementSyntax>() != null) |
||||||
|
{ |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return node.GetAncestors<MemberDeclarationSyntax>().Any( |
||||||
|
m => m.GetModifiers().Any(SyntaxKind.UnsafeKeyword)); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsInStaticContext(this SyntaxNode node) |
||||||
|
{ |
||||||
|
// this/base calls are always static.
|
||||||
|
if (node.FirstAncestorOrSelf<ConstructorInitializerSyntax>() != null) |
||||||
|
{ |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
var memberDeclaration = node.FirstAncestorOrSelf<MemberDeclarationSyntax>(); |
||||||
|
if (memberDeclaration == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
switch (memberDeclaration.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.MethodDeclaration: |
||||||
|
case SyntaxKind.ConstructorDeclaration: |
||||||
|
case SyntaxKind.PropertyDeclaration: |
||||||
|
case SyntaxKind.EventDeclaration: |
||||||
|
case SyntaxKind.IndexerDeclaration: |
||||||
|
return memberDeclaration.GetModifiers().Any(SyntaxKind.StaticKeyword); |
||||||
|
|
||||||
|
case SyntaxKind.FieldDeclaration: |
||||||
|
// Inside a field one can only access static members of a type.
|
||||||
|
return true; |
||||||
|
|
||||||
|
case SyntaxKind.DestructorDeclaration: |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
// Global statements are not a static context.
|
||||||
|
if (node.FirstAncestorOrSelf<GlobalStatementSyntax>() != null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
// any other location is considered static
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
public static NamespaceDeclarationSyntax GetInnermostNamespaceDeclarationWithUsings(this SyntaxNode contextNode) |
||||||
|
{ |
||||||
|
var usingDirectiveAncsestor = contextNode.GetAncestor<UsingDirectiveSyntax>(); |
||||||
|
if (usingDirectiveAncsestor == null) |
||||||
|
{ |
||||||
|
return contextNode.GetAncestorsOrThis<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
// We are inside a using directive. In this case, we should find and return the first 'parent' namespace with usings.
|
||||||
|
var containingNamespace = usingDirectiveAncsestor.GetAncestor<NamespaceDeclarationSyntax>(); |
||||||
|
if (containingNamespace == null) |
||||||
|
{ |
||||||
|
// We are inside a top level using directive (i.e. one that's directly in the compilation unit).
|
||||||
|
return null; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
return containingNamespace.GetAncestors<NamespaceDeclarationSyntax>().FirstOrDefault(n => n.Usings.Count > 0); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns all of the trivia to the left of this token up to the previous token (concatenates
|
||||||
|
/// the previous token's trailing trivia and this token's leading trivia).
|
||||||
|
/// </summary>
|
||||||
|
public static IEnumerable<SyntaxTrivia> GetAllPrecedingTriviaToPreviousToken(this SyntaxToken token) |
||||||
|
{ |
||||||
|
var prevToken = token.GetPreviousToken(includeSkipped: true); |
||||||
|
if (prevToken.Kind() == SyntaxKind.None) |
||||||
|
{ |
||||||
|
return token.LeadingTrivia; |
||||||
|
} |
||||||
|
|
||||||
|
return prevToken.TrailingTrivia.Concat(token.LeadingTrivia); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsBreakableConstruct(this SyntaxNode node) |
||||||
|
{ |
||||||
|
switch (node.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.DoStatement: |
||||||
|
case SyntaxKind.WhileStatement: |
||||||
|
case SyntaxKind.SwitchStatement: |
||||||
|
case SyntaxKind.ForStatement: |
||||||
|
case SyntaxKind.ForEachStatement: |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsContinuableConstruct(this SyntaxNode node) |
||||||
|
{ |
||||||
|
switch (node.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.DoStatement: |
||||||
|
case SyntaxKind.WhileStatement: |
||||||
|
case SyntaxKind.ForStatement: |
||||||
|
case SyntaxKind.ForEachStatement: |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsReturnableConstruct(this SyntaxNode node) |
||||||
|
{ |
||||||
|
switch (node.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.AnonymousMethodExpression: |
||||||
|
case SyntaxKind.SimpleLambdaExpression: |
||||||
|
case SyntaxKind.ParenthesizedLambdaExpression: |
||||||
|
case SyntaxKind.MethodDeclaration: |
||||||
|
case SyntaxKind.ConstructorDeclaration: |
||||||
|
case SyntaxKind.DestructorDeclaration: |
||||||
|
case SyntaxKind.GetAccessorDeclaration: |
||||||
|
case SyntaxKind.SetAccessorDeclaration: |
||||||
|
case SyntaxKind.OperatorDeclaration: |
||||||
|
case SyntaxKind.AddAccessorDeclaration: |
||||||
|
case SyntaxKind.RemoveAccessorDeclaration: |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsAnyArgumentList(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.IsKind(SyntaxKind.ArgumentList) || |
||||||
|
node.IsKind(SyntaxKind.AttributeArgumentList) || |
||||||
|
node.IsKind(SyntaxKind.BracketedArgumentList) || |
||||||
|
node.IsKind(SyntaxKind.TypeArgumentList); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsAnyLambda(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return |
||||||
|
node.IsKind(SyntaxKind.ParenthesizedLambdaExpression) || |
||||||
|
node.IsKind(SyntaxKind.SimpleLambdaExpression); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsAnyLambdaOrAnonymousMethod(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.IsAnyLambda() || node.IsKind(SyntaxKind.AnonymousMethodExpression); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsAnyAssignExpression(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return SyntaxFacts.IsAssignmentExpression(node.Kind()); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsParentKind(this SyntaxNode node, SyntaxKind kind) |
||||||
|
{ |
||||||
|
return node != null && node.Parent.IsKind(kind); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsParentKind(this SyntaxToken node, SyntaxKind kind) |
||||||
|
{ |
||||||
|
return node.Parent != null && node.Parent.IsKind(kind); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsCompoundAssignExpression(this SyntaxNode node) |
||||||
|
{ |
||||||
|
switch (node.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.AddAssignmentExpression: |
||||||
|
case SyntaxKind.SubtractAssignmentExpression: |
||||||
|
case SyntaxKind.MultiplyAssignmentExpression: |
||||||
|
case SyntaxKind.DivideAssignmentExpression: |
||||||
|
case SyntaxKind.ModuloAssignmentExpression: |
||||||
|
case SyntaxKind.AndAssignmentExpression: |
||||||
|
case SyntaxKind.ExclusiveOrAssignmentExpression: |
||||||
|
case SyntaxKind.OrAssignmentExpression: |
||||||
|
case SyntaxKind.LeftShiftAssignmentExpression: |
||||||
|
case SyntaxKind.RightShiftAssignmentExpression: |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsLeftSideOfAssignExpression(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.IsParentKind(SyntaxKind.SimpleAssignmentExpression) && |
||||||
|
((AssignmentExpressionSyntax)node.Parent).Left == node; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsLeftSideOfAnyAssignExpression(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.Parent.IsAnyAssignExpression() && |
||||||
|
((AssignmentExpressionSyntax)node.Parent).Left == node; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsRightSideOfAnyAssignExpression(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node.Parent.IsAnyAssignExpression() && |
||||||
|
((AssignmentExpressionSyntax)node.Parent).Right == node; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsVariableDeclaratorValue(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return |
||||||
|
node.IsParentKind(SyntaxKind.EqualsValueClause) && |
||||||
|
node.Parent.IsParentKind(SyntaxKind.VariableDeclarator) && |
||||||
|
((EqualsValueClauseSyntax)node.Parent).Value == node; |
||||||
|
} |
||||||
|
|
||||||
|
public static BlockSyntax FindInnermostCommonBlock(this IEnumerable<SyntaxNode> nodes) |
||||||
|
{ |
||||||
|
return nodes.FindInnermostCommonNode<BlockSyntax>(); |
||||||
|
} |
||||||
|
|
||||||
|
public static IEnumerable<SyntaxNode> GetAncestorsOrThis(this SyntaxNode node, Func<SyntaxNode, bool> predicate) |
||||||
|
{ |
||||||
|
var current = node; |
||||||
|
while (current != null) |
||||||
|
{ |
||||||
|
if (predicate(current)) |
||||||
|
{ |
||||||
|
yield return current; |
||||||
|
} |
||||||
|
|
||||||
|
current = current.Parent; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
public static SyntaxNode GetParent(this SyntaxNode node) |
||||||
|
{ |
||||||
|
return node != null ? node.Parent : null; |
||||||
|
} |
||||||
|
|
||||||
|
public static ValueTuple<SyntaxToken, SyntaxToken> GetBraces(this SyntaxNode node) |
||||||
|
{ |
||||||
|
var namespaceNode = node as NamespaceDeclarationSyntax; |
||||||
|
if (namespaceNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(namespaceNode.OpenBraceToken, namespaceNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var baseTypeNode = node as BaseTypeDeclarationSyntax; |
||||||
|
if (baseTypeNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(baseTypeNode.OpenBraceToken, baseTypeNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var accessorListNode = node as AccessorListSyntax; |
||||||
|
if (accessorListNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(accessorListNode.OpenBraceToken, accessorListNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var blockNode = node as BlockSyntax; |
||||||
|
if (blockNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(blockNode.OpenBraceToken, blockNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var switchStatementNode = node as SwitchStatementSyntax; |
||||||
|
if (switchStatementNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(switchStatementNode.OpenBraceToken, switchStatementNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var anonymousObjectCreationExpression = node as AnonymousObjectCreationExpressionSyntax; |
||||||
|
if (anonymousObjectCreationExpression != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(anonymousObjectCreationExpression.OpenBraceToken, anonymousObjectCreationExpression.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
var initializeExpressionNode = node as InitializerExpressionSyntax; |
||||||
|
if (initializeExpressionNode != null) |
||||||
|
{ |
||||||
|
return ValueTuple.Create(initializeExpressionNode.OpenBraceToken, initializeExpressionNode.CloseBraceToken); |
||||||
|
} |
||||||
|
|
||||||
|
return new ValueTuple<SyntaxToken, SyntaxToken>(); |
||||||
|
} |
||||||
|
|
||||||
|
public static SyntaxTokenList GetModifiers(this SyntaxNode member) |
||||||
|
{ |
||||||
|
if (member != null) |
||||||
|
{ |
||||||
|
switch (member.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.EnumDeclaration: |
||||||
|
return ((EnumDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.ClassDeclaration: |
||||||
|
case SyntaxKind.InterfaceDeclaration: |
||||||
|
case SyntaxKind.StructDeclaration: |
||||||
|
return ((TypeDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.DelegateDeclaration: |
||||||
|
return ((DelegateDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.FieldDeclaration: |
||||||
|
return ((FieldDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.EventFieldDeclaration: |
||||||
|
return ((EventFieldDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.ConstructorDeclaration: |
||||||
|
return ((ConstructorDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.DestructorDeclaration: |
||||||
|
return ((DestructorDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.PropertyDeclaration: |
||||||
|
return ((PropertyDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.EventDeclaration: |
||||||
|
return ((EventDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.IndexerDeclaration: |
||||||
|
return ((IndexerDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.OperatorDeclaration: |
||||||
|
return ((OperatorDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.ConversionOperatorDeclaration: |
||||||
|
return ((ConversionOperatorDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.MethodDeclaration: |
||||||
|
return ((MethodDeclarationSyntax)member).Modifiers; |
||||||
|
case SyntaxKind.GetAccessorDeclaration: |
||||||
|
case SyntaxKind.SetAccessorDeclaration: |
||||||
|
case SyntaxKind.AddAccessorDeclaration: |
||||||
|
case SyntaxKind.RemoveAccessorDeclaration: |
||||||
|
return ((AccessorDeclarationSyntax)member).Modifiers; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return default(SyntaxTokenList); |
||||||
|
} |
||||||
|
|
||||||
|
public static SyntaxNode WithModifiers(this SyntaxNode member, SyntaxTokenList modifiers) |
||||||
|
{ |
||||||
|
if (member != null) |
||||||
|
{ |
||||||
|
switch (member.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.EnumDeclaration: |
||||||
|
return ((EnumDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.ClassDeclaration: |
||||||
|
case SyntaxKind.InterfaceDeclaration: |
||||||
|
case SyntaxKind.StructDeclaration: |
||||||
|
return ((TypeDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.DelegateDeclaration: |
||||||
|
return ((DelegateDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.FieldDeclaration: |
||||||
|
return ((FieldDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.EventFieldDeclaration: |
||||||
|
return ((EventFieldDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.ConstructorDeclaration: |
||||||
|
return ((ConstructorDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.DestructorDeclaration: |
||||||
|
return ((DestructorDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.PropertyDeclaration: |
||||||
|
return ((PropertyDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.EventDeclaration: |
||||||
|
return ((EventDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.IndexerDeclaration: |
||||||
|
return ((IndexerDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.OperatorDeclaration: |
||||||
|
return ((OperatorDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.ConversionOperatorDeclaration: |
||||||
|
return ((ConversionOperatorDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.MethodDeclaration: |
||||||
|
return ((MethodDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.GetAccessorDeclaration: |
||||||
|
case SyntaxKind.SetAccessorDeclaration: |
||||||
|
case SyntaxKind.AddAccessorDeclaration: |
||||||
|
case SyntaxKind.RemoveAccessorDeclaration: |
||||||
|
return ((AccessorDeclarationSyntax)member).WithModifiers(modifiers); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return null; |
||||||
|
} |
||||||
|
|
||||||
|
public static TypeDeclarationSyntax WithModifiers( |
||||||
|
this TypeDeclarationSyntax node, SyntaxTokenList modifiers) |
||||||
|
{ |
||||||
|
switch (node.Kind()) |
||||||
|
{ |
||||||
|
case SyntaxKind.ClassDeclaration: |
||||||
|
return ((ClassDeclarationSyntax)node).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.InterfaceDeclaration: |
||||||
|
return ((InterfaceDeclarationSyntax)node).WithModifiers(modifiers); |
||||||
|
case SyntaxKind.StructDeclaration: |
||||||
|
return ((StructDeclarationSyntax)node).WithModifiers(modifiers); |
||||||
|
} |
||||||
|
|
||||||
|
throw new InvalidOperationException(); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool CheckTopLevel(this SyntaxNode node, TextSpan span) |
||||||
|
{ |
||||||
|
var block = node as BlockSyntax; |
||||||
|
if (block != null) |
||||||
|
{ |
||||||
|
return block.ContainsInBlockBody(span); |
||||||
|
} |
||||||
|
|
||||||
|
var field = node as FieldDeclarationSyntax; |
||||||
|
if (field != null) |
||||||
|
{ |
||||||
|
foreach (var variable in field.Declaration.Variables) |
||||||
|
{ |
||||||
|
if (variable.Initializer != null && variable.Initializer.Span.Contains(span)) |
||||||
|
{ |
||||||
|
return true; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
var global = node as GlobalStatementSyntax; |
||||||
|
if (global != null) |
||||||
|
{ |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
var constructorInitializer = node as ConstructorInitializerSyntax; |
||||||
|
if (constructorInitializer != null) |
||||||
|
{ |
||||||
|
return constructorInitializer.ContainsInArgument(span); |
||||||
|
} |
||||||
|
|
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
public static bool ContainsInArgument(this ConstructorInitializerSyntax initializer, TextSpan textSpan) |
||||||
|
{ |
||||||
|
if (initializer == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
return initializer.ArgumentList.Arguments.Any(a => a.Span.Contains(textSpan)); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool ContainsInBlockBody(this BlockSyntax block, TextSpan textSpan) |
||||||
|
{ |
||||||
|
if (block == null) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
var blockSpan = TextSpan.FromBounds(block.OpenBraceToken.Span.End, block.CloseBraceToken.SpanStart); |
||||||
|
return blockSpan.Contains(textSpan); |
||||||
|
} |
||||||
|
|
||||||
|
public static bool IsDelegateOrConstructorOrMethodParameterList(this SyntaxNode node) |
||||||
|
{ |
||||||
|
if (!node.IsKind(SyntaxKind.ParameterList)) |
||||||
|
{ |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
return |
||||||
|
node.IsParentKind(SyntaxKind.MethodDeclaration) || |
||||||
|
node.IsParentKind(SyntaxKind.ConstructorDeclaration) || |
||||||
|
node.IsParentKind(SyntaxKind.DelegateDeclaration); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue