public static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
IMethodSymbol methodSymbol,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
InvocationExpressionSyntax invocation = SimpleMemberInvocationExpression(expression.WithoutTrailingTrivia(), IdentifierName(methodSymbol.Name))
.WithTrailingTrivia(expression.GetTrailingTrivia());
SyntaxNode newRoot = root.ReplaceNode(expression, invocation);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (methodSymbol.IsExtensionMethod)
{
INamespaceSymbol namespaceSymbol = methodSymbol.ContainingNamespace;
if (namespaceSymbol != null &&
!CSharpAnalysis.IsNamespaceInScope(expression, namespaceSymbol, semanticModel, cancellationToken) &&
newRoot.IsKind(SyntaxKind.CompilationUnit))
{
newRoot = ((CompilationUnitSyntax)newRoot)
.AddUsings(UsingDirective(ParseName(namespaceSymbol.ToString())));
}
}
return(document.WithSyntaxRoot(newRoot));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IdentifierNameSyntax identifierName)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
INamespaceSymbol namespaceSymbol = null;
SyntaxNode node = identifierName;
SyntaxNode prevNode = null;
while (node?.Parent?.IsKind(SyntaxKind.QualifiedName, SyntaxKind.AliasQualifiedName, SyntaxKind.SimpleMemberAccessExpression) == true)
{
ISymbol symbol = semanticModel.GetSymbol(node, context.CancellationToken);
if (symbol?.IsNamespace() == true)
{
namespaceSymbol = (INamespaceSymbol)symbol;
prevNode = node;
node = node.Parent;
}
else
{
break;
}
}
node = prevNode;
if (node?.IsParentKind(SyntaxKind.QualifiedName, SyntaxKind.AliasQualifiedName, SyntaxKind.SimpleMemberAccessExpression) == true &&
!node.IsDescendantOf(SyntaxKind.UsingDirective) &&
!CSharpAnalysis.IsNamespaceInScope(node, namespaceSymbol, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
$"using {namespaceSymbol};",
cancellationToken => RefactorAsync(context.Document, node, namespaceSymbol, cancellationToken));
}
}
