public bool IsImport(SyntaxNode node, out string importFullName)
{
importFullName = string.Empty;
if (node.GetAncestor<IfDirectiveTriviaSyntax>() != null
|| node.GetAncestor<ElifDirectiveTriviaSyntax>() != null)
{
return false;
}
var usingDirective = node.GetAncestor<UsingDirectiveSyntax>();
importFullName = usingDirective == null ? null : usingDirective.Name.ToString();
return usingDirective != null;
}
public bool IsType(SyntaxNode node)
{
if (node.GetAncestor<UsingDirectiveSyntax>() != null
|| node.Parent is NameMemberCrefSyntax
|| node.Parent is XmlCrefAttributeSyntax
|| node.Parent is XmlNameAttributeSyntax
|| node.Parent is MemberBindingExpressionSyntax
|| node.Parent is ConditionalAccessExpressionSyntax)
{
return false;
}
if (node.Parent is MemberAccessExpressionSyntax)
{
if (!node.Parent.ChildNodes().First().Equals(node))
{
return false;
}
}
return true;
}
public override SyntaxNode GetEffectiveParentForAttribute(SyntaxNode node)
{
if (node.HasAncestor<BaseFieldDeclarationSyntax>())
{
return node.GetAncestor<BaseFieldDeclarationSyntax>().Declaration.Variables.FirstOrDefault();
}
else if (node.HasAncestor<ParameterSyntax>())
{
return node.GetAncestor<ParameterSyntax>();
}
else
{
return node.Parent;
}
}
public override SyntaxNode GetNodeWithAttributes(SyntaxNode node)
{
return node is VariableDeclaratorSyntax
? node.GetAncestor<MemberDeclarationSyntax>()
: node;
}
internal override bool IsAddMethodContext(SyntaxNode node, SemanticModel semanticModel)
{
if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression))
{
var objectCreationExpressionSyntax = node.GetAncestor<ObjectCreationExpressionSyntax>();
if (objectCreationExpressionSyntax == null)
{
return false;
}
return true;
}
return false;
}
protected override bool IsViableExtensionMethod(IMethodSymbol method, SyntaxNode expression, SemanticModel semanticModel, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken)
{
var leftExpression = syntaxFacts.GetExpressionOfMemberAccessExpression(expression) ?? syntaxFacts.GetExpressionOfConditionalMemberAccessExpression(expression);
if (leftExpression == null)
{
if (expression.IsKind(SyntaxKind.CollectionInitializerExpression))
{
leftExpression = expression.GetAncestor<ObjectCreationExpressionSyntax>();
}
else
{
return false;
}
}
var semanticInfo = semanticModel.GetTypeInfo(leftExpression, cancellationToken);
var leftExpressionType = semanticInfo.Type;
return leftExpressionType != null && method.ReduceExtensionMethod(leftExpressionType) != null;
}
private bool UsingsAreContainedInNamespace(SyntaxNode contextNode)
{
return contextNode.GetAncestor<NamespaceDeclarationSyntax>()?.DescendantNodes().OfType<UsingDirectiveSyntax>().FirstOrDefault() != null;
}
protected override bool CanAddImportForMethod(Diagnostic diagnostic, ISyntaxFactsService syntaxFacts, ref SyntaxNode node)
{
switch (diagnostic.Id)
{
case CS1061:
if (node.IsKind(SyntaxKind.ConditionalAccessExpression))
{
node = (node as ConditionalAccessExpressionSyntax).WhenNotNull;
}
else if (node.IsKind(SyntaxKind.MemberBindingExpression))
{
node = (node as MemberBindingExpressionSyntax).Name;
}
else if (node.Parent.IsKind(SyntaxKind.CollectionInitializerExpression))
{
return true;
}
break;
case CS0122:
case CS1501:
if (node is SimpleNameSyntax)
{
break;
}
else if (node is MemberBindingExpressionSyntax)
{
node = (node as MemberBindingExpressionSyntax).Name;
}
break;
case CS1929:
var memberAccessName = (node.Parent as MemberAccessExpressionSyntax)?.Name;
var conditionalAccessName = (((node.Parent as ConditionalAccessExpressionSyntax)?.WhenNotNull as InvocationExpressionSyntax)?.Expression as MemberBindingExpressionSyntax)?.Name;
if (memberAccessName == null && conditionalAccessName == null)
{
return false;
}
node = memberAccessName ?? conditionalAccessName;
break;
case CS1503:
//// look up its corresponding method name
var parent = node.GetAncestor<InvocationExpressionSyntax>();
if (parent == null)
{
return false;
}
var method = parent.Expression as MemberAccessExpressionSyntax;
if (method != null)
{
node = method.Name;
}
break;
default:
return false;
}
var simpleName = node as SimpleNameSyntax;
if (!simpleName.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) &&
!simpleName.IsParentKind(SyntaxKind.MemberBindingExpression))
{
return false;
}
var memberAccess = simpleName.Parent as MemberAccessExpressionSyntax;
var memberBinding = simpleName.Parent as MemberBindingExpressionSyntax;
if (memberAccess.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberAccess.IsParentKind(SyntaxKind.ElementAccessExpression) ||
memberBinding.IsParentKind(SyntaxKind.SimpleMemberAccessExpression) ||
memberBinding.IsParentKind(SyntaxKind.ElementAccessExpression))
{
return false;
}
if (!syntaxFacts.IsMemberAccessExpressionName(node))
{
return false;
}
return true;
}
public bool IsExtension(SyntaxNode node)
{
return (node.Parent is MemberAccessExpressionSyntax)
&& node.GetAncestor<UsingDirectiveSyntax>() == null
&& !node.Parent.ChildNodes().First().Equals(node);
}
public bool IsAttribute(SyntaxNode node)
{
return node.GetAncestor<AttributeSyntax>() != null;
}
static CodeAction Handle(Document document, Microsoft.CodeAnalysis.Text.TextSpan span, SyntaxNode root, SyntaxNode node, ExpressionSyntax iterateOver, bool replaceNode)
{
return CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
"Iterate via 'foreach'",
ct =>
{
ForEachStatementSyntax foreachStmt = BuildForeach(iterateOver);
SyntaxNode newRoot;
var ancestor = node.GetAncestor<StatementSyntax>();
if (replaceNode)
{
newRoot = root.ReplaceNode(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) });
}
else
{
newRoot = root.InsertNodesAfter(ancestor, new[] { foreachStmt.WithTrailingTrivia(ancestor.GetTrailingTrivia()) });
}
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
);
}
CodeAction GetAction(Document document, SemanticModel model, SyntaxNode root, SyntaxNode node, MethodDeclarationSyntax method)
{
return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("Extract anonymous method"), t2 =>
{
var identifier = SyntaxFactory.IdentifierName(NameGenerator.EnsureUniqueness("Method", model.LookupSymbols(node.SpanStart).Select(s => s.Name)));
var surroundingMemberDeclaration = node.GetAncestor<MemberDeclarationSyntax>();
var rootWithTrackedMember = root.TrackNodes(node, surroundingMemberDeclaration);
var newRoot = rootWithTrackedMember.ReplaceNode(rootWithTrackedMember.GetCurrentNode(node), identifier);
newRoot = newRoot
.InsertNodesBefore(newRoot.GetCurrentNode(surroundingMemberDeclaration),
new[] { method.WithTrailingTrivia(surroundingMemberDeclaration.GetTrailingTrivia()) });
return Task.FromResult(document.WithSyntaxRoot(newRoot));
});
}
