public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span, getInnermostNodeForTie: true) as InvocationExpressionSyntax;
var newRoot = root.ReplaceNode(node, MakeOfTypeCall(node, out string methodName));
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, string.Format("Replace with call to OfType<T>().{0}()", methodName), document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindToken(context.Span.Start).Parent.AncestorsAndSelf().OfType <AttributeSyntax>().FirstOrDefault();
if (node == null)
{
return;
}
context.RegisterCodeFix(
CodeActionFactory.Create(
node.Span,
diagnostic.Severity,
GettextCatalog.GetString("Remove attribute"),
(arg) =>
{
var list = node.Parent as AttributeListSyntax;
if (list.Attributes.Count == 1)
{
var newRoot = root.RemoveNode(list, SyntaxRemoveOptions.KeepNoTrivia);
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
var newRoot2 = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
return(Task.FromResult(document.WithSyntaxRoot(newRoot2)));
}
),
diagnostic
);
context.RegisterCodeFix(
CodeActionFactory.Create(
node.Span,
diagnostic.Severity,
GettextCatalog.GetString("Make the field static"),
(arg) =>
{
var field = node.Parent.Parent as FieldDeclarationSyntax;
var newRoot = root.ReplaceNode(field, field.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword)).WithAdditionalAnnotations(Formatter.Annotation));
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
),
diagnostic
);
}
public async Task<IEnumerable<CodeAction>> GetFixesAsync(Document document, TextSpan span, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
var result = new List<CodeAction>();
foreach (var diagonstic in diagnostics)
{
var node = root.FindNode(diagonstic.Location.SourceSpan);
//if (!node.IsKind(SyntaxKind.BaseList))
// continue;
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
result.Add(CodeActionFactory.Create(node.Span, diagonstic.Severity, diagonstic.GetMessage(), document.WithSyntaxRoot(newRoot)));
}
return result;
}
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));
}));
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span);
var newRoot = root.ReplaceNode((SyntaxNode)node, RedundantPrivateAnalyzer.RemoveModifierFromNode(node, SyntaxKind.PrivateKeyword).WithAdditionalAnnotations(Formatter.Annotation));
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove redundant 'private' modifier", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span);
var newRoot = root.ReplaceNode(node, RemoveInternalModifier(node));
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove redundant 'internal' modifier", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span, getInnermostNodeForTie: true) as InvocationExpressionSyntax;
var newRoot = root.ReplaceNode(node, ReplaceWithOfTypeAnyAnalyzer.MakeOfTypeCall(node));
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Replace with call to OfType<T>().LongCount()", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span).Parent;
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove redundant statement", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var token = root.FindToken(span.Start);
var castExpression = token.Parent.AncestorsAndSelf().OfType <CastExpressionSyntax>().FirstOrDefault();
if (castExpression == null || castExpression.IsKind(SyntaxKind.TryCastExpression) || castExpression.Expression.Span.Contains(span))
{
return;
}
var type = model.GetTypeInfo(castExpression.Type).Type;
if (type == null || type.IsValueType && !type.IsNullableType())
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
token.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Convert cast to 'TryCast'"),
t2 => Task.FromResult(PerformAction(document, root, castExpression))
)
);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span, getInnermostNodeForTie: true) as InvocationExpressionSyntax;
var newRoot = root.ReplaceNode(node, ReplaceWithSingleCallToAnyAnalyzer.MakeSingleCall(node));
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Replace with single call to 'SingleOrDefault'", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span) as CaseSwitchLabelSyntax;
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, string.Format("Remove 'case {0}'", node.Value), document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var model = await document.GetSemanticModelAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span) as ConditionalExpressionSyntax;
if (node == null)
{
return;
}
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Replace '?:' operator with '??", token =>
{
ExpressionSyntax a, other;
if (node.Condition.SkipParens().IsKind(SyntaxKind.EqualsExpression))
{
a = node.WhenFalse;
other = node.WhenTrue;
}
else
{
other = node.WhenFalse;
a = node.WhenTrue;
}
if (node.Condition.SkipParens().IsKind(SyntaxKind.EqualsExpression))
{
var castExpression = other as CastExpressionSyntax;
if (castExpression != null)
{
a = SyntaxFactory.CastExpression(castExpression.Type, a);
other = castExpression.Expression;
}
}
a = ConvertConditionalTernaryToNullCoalescingAnalyzer.UnpackNullableValueAccess(model, a, token);
ExpressionSyntax newNode = SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, a, CSharpUtil.AddParensIfRequired(other));
var newRoot = root.ReplaceNode((SyntaxNode)node, newNode.WithLeadingTrivia(node.GetLeadingTrivia()).WithAdditionalAnnotations(Formatter.Annotation));
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}), diagnostic);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var varDecl = root.FindToken(context.Span.Start).Parent.AncestorsAndSelf().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
if (varDecl == null)
{
return;
}
context.RegisterCodeFix(
CodeActionFactory.Create(
context.Span,
diagnostic.Severity,
GettextCatalog.GetString("To 'readonly'"),
delegate(CancellationToken cancellationToken)
{
var fieldDeclaration = varDecl.Ancestors().OfType <FieldDeclarationSyntax>().First();
var nodes = new List <SyntaxNode>();
if (fieldDeclaration.Declaration.Variables.Count == 1)
{
nodes.Add(
fieldDeclaration
.AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))
.WithAdditionalAnnotations(Formatter.Annotation)
);
}
else
{
nodes.Add(fieldDeclaration.WithDeclaration(fieldDeclaration.Declaration.RemoveNode(varDecl, SyntaxRemoveOptions.KeepEndOfLine)));
nodes.Add(
fieldDeclaration.WithDeclaration(
SyntaxFactory.VariableDeclaration(
fieldDeclaration.Declaration.Type,
SyntaxFactory.SeparatedList(new[] { varDecl })
)
)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))
.WithAdditionalAnnotations(Formatter.Annotation)
);
}
return(Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(fieldDeclaration, nodes))));
}
),
diagnostic
);
}
protected override IEnumerable <CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, VariableDeclaratorSyntax node, CancellationToken cancellationToken)
{
var variableDecl = node.Parent.Parent as LocalDeclarationStatementSyntax;
if (variableDecl == null || node.Initializer != null)
{
yield break;
}
var block = variableDecl.Parent as BlockSyntax;
StatementSyntax nextStatement = null;
for (int i = 0; i < block.Statements.Count; i++)
{
if (block.Statements[i] == variableDecl && i + 1 < block.Statements.Count)
{
nextStatement = block.Statements[i + 1];
break;
}
}
var expr = nextStatement as ExpressionStatementSyntax;
if (expr == null)
{
yield break;
}
var assignment = expr.Expression as AssignmentExpressionSyntax;
if (assignment == null || assignment.Left.ToString() != node.Identifier.ToString())
{
yield break;
}
yield return
(CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Join declaration and assignment"),
t2 =>
{
root = root.TrackNodes(new SyntaxNode[] { node, nextStatement });
var newRoot = root.ReplaceNode((SyntaxNode)
root.GetCurrentNode(node),
node.WithInitializer(SyntaxFactory.EqualsValueClause(assignment.Right)).WithAdditionalAnnotations(Formatter.Annotation)
);
newRoot = newRoot.RemoveNode(newRoot.GetCurrentNode(nextStatement), SyntaxRemoveOptions.KeepNoTrivia);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
));
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var token = root.FindToken(span.Start);
if (!token.IsKind(SyntaxKind.IntegerLiteralToken))
{
return;
}
var value = token.Value;
if (!((value is int) || (value is long) || (value is short) || (value is sbyte) ||
(value is uint) || (value is ulong) || (value is ushort) || (value is byte)))
{
return;
}
var literalValue = token.ToString();
if (literalValue.StartsWith("&H", System.StringComparison.OrdinalIgnoreCase))
{
return;
}
context.RegisterRefactoring(CodeActionFactory.Create(token.Span, DiagnosticSeverity.Info, GettextCatalog.GetString("To hex"), t2 => Task.FromResult(PerformAction(document, root, token))));
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span, getInnermostNodeForTie: true) as InvocationExpressionSyntax;
var newRoot = root.ReplaceNode(node, ReplaceWithSingleCallToAnyAnalyzer.MakeSingleCall(node));
var member = ((MemberAccessExpressionSyntax)node.Expression).Name;
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, string.Format("Replace with single call to '{0}'", member.Identifier.ValueText), document.WithSyntaxRoot(newRoot)), diagnostic);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var token = root.FindToken(span.Start);
if (!token.IsKind(SyntaxKind.StringLiteralToken) || token.Value.ToString() != "")
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
token.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Use 'string.Empty'"),
t2 =>
{
var newRoot = root.ReplaceNode((SyntaxNode)token.Parent, SyntaxFactory.ParseExpression("string.Empty"));
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
)
);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var diagnostic = context.Diagnostics.First();
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var node = root.FindNode(span) as MethodDeclarationSyntax;
if (node == null || !node.Identifier.Span.Contains(span))
{
return;
}
context.RegisterCodeFix(
CodeActionFactory.Create(
node.Span,
DiagnosticSeverity.Error,
GettextCatalog.GetString("Remove 'partial'"),
t => Task.FromResult(
document.WithSyntaxRoot(
root.ReplaceNode(
(SyntaxNode)node,
node.WithModifiers(SyntaxFactory.TokenList(node.Modifiers.Where(m => !m.IsKind(SyntaxKind.PartialKeyword))))
.WithLeadingTrivia(node.GetLeadingTrivia())
)
)
)
),
diagnostic
);
}
static void RegisterFix(CodeFixContext context, SemanticModel model, SyntaxNode root, Diagnostic diagnostic, InvocationExpressionSyntax invocationExpression, string stringComparison, string message, CancellationToken cancellationToken = default(CancellationToken))
{
bool? ignoreCase = null;
ExpressionSyntax caseArg = null;
if (invocationExpression.ArgumentList.Arguments.Count == 3)
{
var arg = model.GetConstantValue(invocationExpression.ArgumentList.Arguments[2].Expression, cancellationToken);
if (arg.HasValue)
{
ignoreCase = (bool)arg.Value;
}
else
{
caseArg = invocationExpression.ArgumentList.Arguments[2].Expression;
}
}
if (invocationExpression.ArgumentList.Arguments.Count == 6)
{
var arg = model.GetConstantValue(invocationExpression.ArgumentList.Arguments[5].Expression, cancellationToken);
if (arg.HasValue)
{
ignoreCase = (bool)arg.Value;
}
else
{
caseArg = invocationExpression.ArgumentList.Arguments[5].Expression;
}
}
var argumentList = new List <ArgumentSyntax>();
if (invocationExpression.ArgumentList.Arguments.Count <= 3)
{
argumentList.AddRange(invocationExpression.ArgumentList.Arguments.Take(2));
}
else
{
argumentList.AddRange(invocationExpression.ArgumentList.Arguments.Take(5));
}
argumentList.Add(SyntaxFactory.Argument(CreateCompareArgument(invocationExpression, ignoreCase, caseArg, stringComparison)));
var newArguments = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argumentList));
var newInvocation = SyntaxFactory.InvocationExpression(invocationExpression.Expression, newArguments);
var newRoot = root.ReplaceNode(invocationExpression, newInvocation.WithAdditionalAnnotations(Formatter.Annotation));
context.RegisterCodeFix(CodeActionFactory.Create(invocationExpression.Span, diagnostic.Severity, message, context.Document.WithSyntaxRoot(newRoot)), diagnostic);
}
internal static void RegisterFix(CodeFixContext context, SyntaxNode root, Diagnostic diagnostic, InvocationExpressionSyntax invocationExpression, string stringComparison, string message, CancellationToken cancellationToken = default(CancellationToken))
{
var stringComparisonType = SyntaxFactory.ParseTypeName("System.StringComparison").WithAdditionalAnnotations(Microsoft.CodeAnalysis.Simplification.Simplifier.Annotation);
var stringComparisonArgument = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, stringComparisonType, (SimpleNameSyntax)SyntaxFactory.ParseName(stringComparison));
var ma = invocationExpression.Expression as MemberAccessExpressionSyntax;
var newArguments = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] {
SyntaxFactory.Argument(ma.Expression),
invocationExpression.ArgumentList.Arguments[0],
SyntaxFactory.Argument(stringComparisonArgument)
}));
var newInvocation = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("string.Compare"), newArguments);
var newRoot = root.ReplaceNode(invocationExpression, newInvocation.WithAdditionalAnnotations(Formatter.Annotation));
context.RegisterCodeFix(CodeActionFactory.Create(invocationExpression.Span, diagnostic.Severity, message, context.Document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span);
//if (!node.IsKind(SyntaxKind.BaseList))
// continue;
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove '{0}'", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
{
return;
}
var span = context.Span;
if (!span.IsEmpty)
{
return;
}
var cancellationToken = context.CancellationToken;
if (cancellationToken.IsCancellationRequested)
{
return;
}
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var node = root.FindToken(span.Start).Parent as InterpolatedStringTextSyntax;
if (node == null)
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
node.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("To format string"),
t =>
{
var newRoot = root.ReplaceNode(node.Parent, CreateFormatString(node));
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
}
)
);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var document = context.Document;
var span = context.Span;
var cancellationToken = context.CancellationToken;
var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (model.IsFromGeneratedCode(cancellationToken))
{
return;
}
var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
var node = root.FindNode(span) as IfStatementSyntax;
if (node == null)
{
return;
}
ExpressionSyntax condition;
ReturnStatementSyntax return1, return2, rs;
if (!ConvertIfStatementToReturnStatementAction.GetMatch(node, out condition, out return1, out return2, out rs))
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Replace with 'return'"),
t2 =>
{
var newRoot = root.ReplaceNode((SyntaxNode)node, SyntaxFactory.ReturnStatement(CreateCondition(condition, return1, return2)).WithAdditionalAnnotations(Formatter.Annotation).WithLeadingTrivia(node.GetLeadingTrivia()));
if (rs != null)
{
var retToRemove = newRoot.DescendantNodes().OfType <ReturnStatementSyntax>().FirstOrDefault(r => r.IsEquivalentTo(rs));
newRoot = newRoot.RemoveNode(retToRemove, SyntaxRemoveOptions.KeepNoTrivia);
}
return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
})
);
}
protected override IEnumerable <CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, BinaryExpressionSyntax node, CancellationToken cancellationToken)
{
if (!node.IsKind(SyntaxKind.IsExpression) || !node.OperatorToken.Span.Contains(span))
{
return(Enumerable.Empty <CodeAction>());
}
var pExpr = node.Parent as ParenthesizedExpressionSyntax;
if (pExpr != null)
{
var uOp = pExpr.Parent as PrefixUnaryExpressionSyntax;
if (uOp != null && uOp.IsKind(SyntaxKind.LogicalNotExpression))
{
return(new[] {
CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
string.Format(GettextCatalog.GetString("Negate '{0}'"), uOp),
t2 => {
var newRoot = root.ReplaceNode((SyntaxNode)
(SyntaxNode)uOp,
node.WithAdditionalAnnotations(Formatter.Annotation)
);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
)
});
}
}
return(new[] {
CodeActionFactory.Create(
span,
DiagnosticSeverity.Info,
string.Format("Negate '{0}'", node),
t2 => {
var newRoot = root.ReplaceNode((SyntaxNode)
(SyntaxNode)node,
SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, SyntaxFactory.ParenthesizedExpression(node)).WithAdditionalAnnotations(Formatter.Annotation)
);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
)
});
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span);
if (node.IsKind(SyntaxKind.NameEquals))
{
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepLeadingTrivia);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove redundant name", document.WithSyntaxRoot(newRoot)), diagnostic);
}
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span);
if (node.IsKind(SyntaxKind.TrueLiteralExpression))
{
var newRoot = root.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, diagnostic.GetMessage(), document.WithSyntaxRoot(newRoot)), diagnostic);
}
}
protected override IEnumerable <CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, ForStatementSyntax node, CancellationToken cancellationToken)
{
if (!node.ForKeyword.Span.Contains(span))
{
return(Enumerable.Empty <CodeAction>());
}
return(new[] { CodeActionFactory.Create(
node.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("To 'while'"),
t2 => {
var statements = new List <StatementSyntax>();
var blockSyntax = node.Statement as BlockSyntax;
if (blockSyntax != null)
{
statements.AddRange(blockSyntax.Statements);
}
else
{
statements.Add(node.Statement);
}
statements.AddRange(node.Incrementors.Select(i => SyntaxFactory.ExpressionStatement(i)));
var whileStatement = SyntaxFactory.WhileStatement(
node.Condition ?? SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression),
SyntaxFactory.Block(statements));
var replaceStatements = new List <StatementSyntax>();
if (node.Declaration != null)
{
replaceStatements.Add(SyntaxFactory.LocalDeclarationStatement(node.Declaration).WithAdditionalAnnotations(Formatter.Annotation));
}
foreach (var init in node.Initializers)
{
replaceStatements.Add(SyntaxFactory.ExpressionStatement(init).WithAdditionalAnnotations(Formatter.Annotation));
}
replaceStatements.Add(whileStatement.WithAdditionalAnnotations(Formatter.Annotation));
replaceStatements[0] = replaceStatements[0].WithLeadingTrivia(node.GetLeadingTrivia());
var newRoot = root.ReplaceNode((SyntaxNode)node, replaceStatements);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
) });
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
var constructorParameterContext = await ConstructorParameterContextFinder.Find(context);
if (constructorParameterContext == null)
{
return;
}
context.RegisterRefactoring(
CodeActionFactory.Create(
constructorParameterContext.TextSpan,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Initialize auto-property from parameter"),
t => CreateAndInitialiseAutoPropertyFromConstructorParameter(constructorParameterContext)
)
);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span) as BinaryExpressionSyntax;
if (node == null)
{
return;
}
StatementSyntax expression = null;
var ifStatement = node.Parent as IfStatementSyntax;
if (ifStatement == null)
{
return;
}
var statement = ifStatement.Statement;
if (statement is BlockSyntax)
{
expression = ((BlockSyntax)statement).Statements[0];
}
else
{
expression = statement;
}
if (expression == null)
{
return;
}
expression = expression
.WithOrderedTriviaFromSubTree(ifStatement)
.WithAdditionalAnnotations(Formatter.Annotation);
var newRoot = root.ReplaceNode(ifStatement, expression);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove redundant check", document.WithSyntaxRoot(newRoot)), diagnostic);
}
public async override Task RegisterCodeFixesAsync(CodeFixContext context)
{
var document = context.Document;
var cancellationToken = context.CancellationToken;
var span = context.Span;
var diagnostics = context.Diagnostics;
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var diagnostic = diagnostics.First();
var node = root.FindNode(context.Span).DescendantNodesAndSelf().OfType <InvocationExpressionSyntax>().First();
if (node == null)
{
return;
}
var newRoot = root.ReplaceNode((SyntaxNode)node, ((MemberAccessExpressionSyntax)node.Expression).Expression);
context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove call to 'object.GetType()'", document.WithSyntaxRoot(newRoot)), diagnostic);
}
