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