public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var serializedNamingStyle = diagnostic.Properties[nameof(NamingStyle)]; var style = NamingStyle.FromXElement(XElement.Parse(serializedNamingStyle)); var document = context.Document; var span = context.Span; var root = await document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var node = root.FindNode(span); var model = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); var symbol = model.GetDeclaredSymbol(node, context.CancellationToken); var fixedNames = style.MakeCompliant(symbol.Name); foreach (var fixedName in fixedNames) { var solution = context.Document.Project.Solution; context.RegisterCodeFix( new FixNameCodeAction( string.Format(FeaturesResources.FixNamingViolation, fixedName), async c => await Renamer.RenameSymbolAsync( solution, symbol, fixedName, document.Options, c).ConfigureAwait(false), nameof(AbstractNamingStyleCodeFixProvider)), diagnostic); } }
public override Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( new PreferFrameworkTypeCodeAction( FeaturesResources.Use_framework_type, c => CreateChangedDocumentAsync(context.Document, context.Span, c)), context.Diagnostics); return SpecializedTasks.EmptyTask; }
private void RegisterSuppressionFixes(CodeFixContext context, IEnumerable<CodeFix> suppressionFixes) { if (suppressionFixes != null) { foreach (var suppressionFix in suppressionFixes) { context.RegisterCodeFix(suppressionFix.Action, suppressionFix.Diagnostics); } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var span = context.Span; var diagnostics = context.Diagnostics; var cancellationToken = context.CancellationToken; var project = document.Project; var diagnostic = diagnostics.First(); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var node = root.FindToken(span.Start).GetAncestors<SyntaxNode>().First(n => n.Span.Contains(span)); using (Logger.LogBlock(FunctionId.Refactoring_FullyQualify, cancellationToken)) { // Has to be a simple identifier or generic name. if (node == null || !CanFullyQualify(diagnostic, ref node)) { return; } var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var matchingTypes = await this.GetMatchingTypesAsync(project, semanticModel, node, cancellationToken).ConfigureAwait(false); var matchingNamespaces = await this.GetMatchingNamespacesAsync(project, semanticModel, node, cancellationToken).ConfigureAwait(false); if (matchingTypes.IsEmpty && matchingNamespaces.IsEmpty) { return; } var matchingTypeContainers = FilterAndSort(GetContainers(matchingTypes, semanticModel.Compilation)); var matchingNamespaceContainers = FilterAndSort(GetContainers(matchingNamespaces, semanticModel.Compilation)); var proposedContainers = matchingTypeContainers.Concat(matchingNamespaceContainers) .Distinct() .Take(MaxResults); var displayService = project.LanguageServices.GetService<ISymbolDisplayService>(); var codeActions = CreateActions(context, document, diagnostic, node, semanticModel, proposedContainers, displayService).ToImmutableArray(); if (codeActions.Length > 1) { // Wrap the spell checking actions into a single top level suggestion // so as to not clutter the list. context.RegisterCodeFix(new GroupingCodeAction( string.Format(FeaturesResources.Fully_qualify_0, GetNodeName(document, node)), codeActions), context.Diagnostics); } else { context.RegisterFixes(codeActions, context.Diagnostics); } } }
public async override Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostics = context.Diagnostics.WhereAsArray(_suppressionFixProvider.CanBeSuppressedOrUnsuppressed); var suppressionFixes = await _suppressionFixProvider.GetSuppressionsAsync(context.Document, context.Span, diagnostics, context.CancellationToken).ConfigureAwait(false); if (suppressionFixes != null) { foreach (var suppressionFix in suppressionFixes) { context.RegisterCodeFix(suppressionFix.Action, suppressionFix.Diagnostics); } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); if (!TryGetNode(root, context.Span, out var node)) { return; } var diagnostic = context.Diagnostics.FirstOrDefault(); var codeAction = await GetCodeFixAsync(root, node, context.Document, diagnostic, context.CancellationToken).ConfigureAwait(false); if (codeAction != null) { context.RegisterCodeFix(codeAction, diagnostic); } }
public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) { var project = context.Document.Project; var publicSurfaceAreaDocument = PublicApiFixHelpers.GetUnshippedDocument(project); foreach (Diagnostic diagnostic in context.Diagnostics) { string minimalSymbolName = diagnostic.Properties[DeclarePublicApiAnalyzer.MinimalNamePropertyBagKey]; string publicSurfaceAreaSymbolName = diagnostic.Properties[DeclarePublicApiAnalyzer.PublicApiNamePropertyBagKey]; ImmutableHashSet <string> siblingSymbolNamesToRemove = diagnostic.Properties[DeclarePublicApiAnalyzer.PublicApiNamesOfSiblingsToRemovePropertyBagKey] .Split(DeclarePublicApiAnalyzer.PublicApiNamesOfSiblingsToRemovePropertyBagValueSeparator.ToCharArray()) .ToImmutableHashSet(); context.RegisterCodeFix( new AdditionalDocumentChangeAction( $"Add {minimalSymbolName} to public API", c => GetFixAsync(publicSurfaceAreaDocument, project, publicSurfaceAreaSymbolName, siblingSymbolNamesToRemove, c)), diagnostic); } return(Task.CompletedTask); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); Diagnostic diagnostic = context.Diagnostics.First(); TextSpan diagnosticSpan = diagnostic.Location.SourceSpan; // find the node which is the "TestContext" type identifier // the parent of the parent is the declaration we want to remove if (root != null) { SyntaxNode node = root.FindToken(diagnosticSpan.Start).Parent; // Register a code action that will invoke the fix. context.RegisterCodeFix( CodeAction.Create( title: Title, createChangedDocument: c => TestContextFix(context.Document, node, c), equivalenceKey: Title), 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 classDecl = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType <ClassDeclarationSyntax>().FirstOrDefault(); if (classDecl == null) { return; } // Register a code action that will invoke the fix. context.RegisterCodeFix( CodeAction.Create( title: Title, createChangedDocument: c => AddAttributeAsync(context.Document, classDecl, c), equivalenceKey: Title), diagnostic); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { SemanticModel model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); INamedTypeSymbol?flagsAttributeType = model.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemFlagsAttribute); if (flagsAttributeType == null) { return; } foreach (var diagnostic in context.Diagnostics) { string fixTitle = diagnostic.Id == EnumWithFlagsAttributeAnalyzer.RuleIdMarkEnumsWithFlags ? MicrosoftCodeQualityAnalyzersResources.MarkEnumsWithFlagsCodeFix : MicrosoftCodeQualityAnalyzersResources.DoNotMarkEnumsWithFlagsCodeFix; context.RegisterCodeFix(new MyCodeAction(fixTitle, async ct => await AddOrRemoveFlagsAttribute(context.Document, context.Span, diagnostic.Id, flagsAttributeType, ct).ConfigureAwait(false), equivalenceKey: fixTitle), diagnostic); } }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { SemanticModel model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); INamedTypeSymbol flagsAttributeType = WellKnownTypes.FlagsAttribute(model.Compilation); if (flagsAttributeType == null) { return; } // We cannot have multiple overlapping diagnostics of this id. Diagnostic diagnostic = context.Diagnostics.Single(); string fixTitle = diagnostic.Id == EnumWithFlagsAttributeAnalyzer.RuleIdMarkEnumsWithFlags ? MicrosoftApiDesignGuidelinesAnalyzersResources.MarkEnumsWithFlagsCodeFix : MicrosoftApiDesignGuidelinesAnalyzersResources.DoNotMarkEnumsWithFlagsCodeFix; context.RegisterCodeFix(new MyCodeAction(fixTitle, async ct => await AddOrRemoveFlagsAttribute(context.Document, context.Span, diagnostic.Id, flagsAttributeType, ct).ConfigureAwait(false), equivalenceKey: fixTitle), diagnostic); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); StatementSyntax statement = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <StatementSyntax>(); Debug.Assert(statement != null, $"{nameof(statement)} is null"); if (statement == null) { return; } CodeAction codeAction = CodeAction.Create( "Remove unreachable code", cancellationToken => Remover.RemoveStatementAsync(context.Document, statement, cancellationToken), DiagnosticIdentifiers.RemoveUnreachableCode + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var invocation = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as InvocationExpressionSyntax; var memberAccess = invocation?.Expression as MemberAccessExpressionSyntax; if (memberAccess == null) { return; } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.ReplaceNode(invocation, memberAccess.Expression.WithTriviaFrom(invocation)); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }), context.Diagnostics); }
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var member = root.FindNode(diagnosticSpan) as MemberDeclarationSyntax; if (member == null) { return; } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(member, SyntaxRemoveOptions.KeepNoTrivia); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }), context.Diagnostics); }
/// <inheritdoc /> public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken); var node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true); SyntaxNode presentArgument = node is VariableDeclaratorSyntax declaratorSyntax?SyntaxFactory.IdentifierName(declaratorSyntax.Identifier) : node.Parent is InvocationExpressionSyntax ? null // direct GetService result invocation : node is NameSyntax ? node : node is MemberAccessExpressionSyntax ? node : null; if (presentArgument != null) { context.RegisterCodeFix( CodeAction.Create( "Add Assumes.Present after assignment", ct => AppendAfterAssignmentAsync(context, node.FirstAncestorOrSelf <StatementSyntax>(), presentArgument, ct), "After"), diagnostic); } }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); if (root?.FindNode(context.Span, getInnermostNodeForTie: true) is not InvocationExpressionSyntax nodeToFix) { return; } if (nodeToFix.Expression is not MemberAccessExpressionSyntax) { return; } var title = "Use StringComparer.Ordinal"; var codeAction = CodeAction.Create( title, ct => AddStringComparison(context.Document, nodeToFix, ct), equivalenceKey: title); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf( root, context.Span, out SyntaxNode node, predicate: f => f.IsKind(SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression, SyntaxKind.IsPatternExpression))) { return; } Diagnostic diagnostic = context.Diagnostics[0]; CodeAction codeAction = CodeAction.Create( "Use 'is' operator", cancellationToken => UseIsOperatorInsteadOfAsOperatorRefactoring.RefactorAsync(context.Document, node, cancellationToken), GetEquivalenceKey(diagnostic)); context.RegisterCodeFix(codeAction, 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 name = diagnostic.Properties[Constants.DiagnosticName]; var description = diagnostic.Properties[Constants.DiagnosticDescription]; var param = root.FindNode(diagnostic.Location.SourceSpan, true) as XmlElementSyntax; var newParam = param.WithContent( SyntaxFactory.SingletonList <XmlNodeSyntax>( SyntaxFactory.XmlText().WithTextTokens( SyntaxFactory.TokenList( SyntaxFactory.XmlTextLiteral(SyntaxFactory.TriviaList(), description, description, SyntaxFactory.TriviaList()) )))); context.RegisterCodeFix( CodeAction.Create($"Update '{name}' description", token => Task.FromResult(context.Document.WithSyntaxRoot(root.ReplaceNode(param, newParam))), string.Concat(diagnostic.Id, name)), diagnostic); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document .GetSyntaxRootAsync(context.CancellationToken) .ConfigureAwait(false); NamespaceDeclarationSyntax declaration = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <NamespaceDeclarationSyntax>(); if (declaration == null) { return; } CodeAction codeAction = CodeAction.Create( "Remove empty namespace declaration", cancellationToken => RemoveEmptyNamespaceDeclarationAsync(context.Document, declaration, cancellationToken), DiagnosticIdentifiers.RemoveEmptyNamespaceDeclaration + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
protected override Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; if (!(root.FindNode(diagnosticSpan) is CaseSwitchLabelSyntax syntaxNode)) { return(TaskHelper.CompletedTask); } context.RegisterCodeFix( CodeAction.Create( Title, c => { var newRoot = root.RemoveNode(syntaxNode, SyntaxRemoveOptions.KeepNoTrivia); return(Task.FromResult(context.Document.WithSyntaxRoot(newRoot))); }), context.Diagnostics); return(TaskHelper.CompletedTask); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); IfStatementSyntax ifStatement = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <IfStatementSyntax>(); if (ifStatement == null) { return; } ifStatement = IfElseChain.GetTopmostIf(ifStatement); CodeAction codeAction = CodeAction.Create( "Add braces to if-else", cancellationToken => AddBracesToIfElseRefactoring.RefactorAsync(context.Document, ifStatement, cancellationToken), DiagnosticIdentifiers.AddBracesToIfElse + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out EndRegionDirectiveTriviaSyntax endRegionDirective, findInsideTrivia: true)) { return; } RegionDirectiveTriviaSyntax regionDirective = endRegionDirective.GetRegionDirective(); SyntaxTrivia trivia = regionDirective.GetPreprocessingMessageTrivia(); CodeAction codeAction = CodeAction.Create( (trivia.IsKind(SyntaxKind.PreprocessingMessageTrivia)) ? "Add region name to #endregion" : "Remove region name from #endregion", cancellationToken => AddOrRemoveRegionNameRefactoring.RefactorAsync(context.Document, endRegionDirective, trivia, cancellationToken), GetEquivalenceKey(DiagnosticIdentifiers.AddOrRemoveRegionName)); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public static void Register( CodeFixContext context, Diagnostic diagnostic, InvocationExpressionSyntax invocation) { string propertyName = diagnostic.Properties["PropertyName"]; string sign = (invocation.Parent?.IsKind(SyntaxKind.LogicalNotExpression) == true) ? "==" : ">"; CodeAction codeAction = CodeAction.Create( $"Replace 'Any' with '{propertyName} {sign} 0'", cancellationToken => { return(RefactorAsync( context.Document, invocation, propertyName, cancellationToken)); }, diagnostic.Id + BaseCodeFixProvider.EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, 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; Debug.Assert(root != null); var parent = root.FindToken(diagnosticSpan.Start).Parent; if (parent != null) { // Find the type declaration identified by the diagnostic. var variableDeclaration = parent.FirstAncestorOrSelf <VariableDeclarationSyntax>(); // Register a code action that will invoke the fix. context.RegisterCodeFix( new AsyncLambdaVariableCodeAction("Async lambdas should not be stored in void-returning delegates", c => ChangeToFunc(context.Document, variableDeclaration, c)), diagnostic); } }
protected sealed override Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; var unary = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as UnaryExpressionSyntax; var isExpression = unary?.Operand as BinaryExpressionSyntax; if (isExpression == null || !isExpression.IsKind(SyntaxKind.IsExpression)) { return(TaskHelper.CompletedTask); } context.RegisterCodeFix( CodeAction.Create( Title, c => ChangeToIsNotAsync(context.Document, unary, isExpression, c)), context.Diagnostics); return(TaskHelper.CompletedTask); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken); foreach (var diagnostic in context.Diagnostics) { var span = diagnostic.Location.SourceSpan; var classDecl = root.FindToken(span.Start).Parent.AncestorsAndSelf().OfType <ClassDeclarationSyntax>().First(); if (!diagnostic.Properties.TryGetValue("requiredAttributes", out var requiredAttributes)) { return; } context.RegisterCodeFix( CodeAction.Create( Title, c => FixAsync(context.Document, classDecl, requiredAttributes, c), Title), diagnostic); } }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { Diagnostic diagnostic = context.Diagnostics[0]; if (!Settings.IsEnabled(diagnostic.Id, CodeFixIdentifiers.SynchronizeAccessibility)) { return; } SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberDeclarationSyntax memberDeclaration)) { return; } SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false); var symbol = (INamedTypeSymbol)semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken); ImmutableArray <MemberDeclarationSyntax> memberDeclarations = ImmutableArray.CreateRange( symbol.DeclaringSyntaxReferences, f => (MemberDeclarationSyntax)f.GetSyntax(context.CancellationToken)); foreach (Accessibility accessibility in memberDeclarations .Select(f => SyntaxAccessibility.GetExplicitAccessibility(f)) .Where(f => f != Accessibility.NotApplicable)) { if (SyntaxAccessibility.IsValidAccessibility(memberDeclaration, accessibility)) { CodeAction codeAction = CodeAction.Create( $"Change accessibility to '{SyntaxFacts.GetText(accessibility)}'", cancellationToken => ChangeAccessibilityRefactoring.RefactorAsync(context.Solution(), memberDeclarations, accessibility, cancellationToken), GetEquivalenceKey(CompilerDiagnosticIdentifiers.PartialDeclarationsHaveConflictingAccessibilityModifiers, accessibility.ToString())); context.RegisterCodeFix(codeAction, 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 InitializerExpressionSyntax; //if (!node.IsKind(SyntaxKind.BaseList)) // continue; if (node == null) { return; } var elementCount = node.Expressions.Count; if (elementCount > node.Expressions.GetSeparators().Count()) { return; } var redundantComma = node.Expressions.GetSeparator(elementCount - 1); var newSeparatedExpList = new List <SyntaxNodeOrToken>(node.Expressions.GetWithSeparators().Where(t => t != redundantComma)); var lastExp = newSeparatedExpList.Last(); newSeparatedExpList.RemoveAt(newSeparatedExpList.Count - 1); newSeparatedExpList.Add(lastExp.WithTrailingTrivia(redundantComma.TrailingTrivia)); var newRoot = root.ReplaceNode( node, node .WithExpressions(SyntaxFactory.SeparatedList <ExpressionSyntax>(SyntaxFactory.NodeOrTokenList(newSeparatedExpList)))); context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove ','", 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 semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var root = semanticModel.SyntaxTree.GetRoot(cancellationToken); var diagnostic = diagnostics.First(); var node = root.FindNode(context.Span); if (node == null) { return; } var typeInfo = semanticModel.GetSymbolInfo(node.Parent); var newType = typeInfo.Symbol.ContainingType.ToMinimalDisplayString(semanticModel, node.SpanStart); var newRoot = root.ReplaceNode((SyntaxNode)node, SyntaxFactory.ParseTypeName(newType).WithLeadingTrivia(node.GetLeadingTrivia())); context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, string.Format("Use base qualifier '{0}'", newType), document.WithSyntaxRoot(newRoot)), diagnostic); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out CaseSwitchLabelSyntax label)) { return; } CodeAction codeAction = CodeAction.Create( "Remove unnecessary case label", cancellationToken => { return(RemoveUnnecessaryCaseLabelRefactoring.RefactorAsync( context.Document, label, cancellationToken)); }, GetEquivalenceKey(DiagnosticIdentifiers.RemoveUnnecessaryCaseLabel)); context.RegisterCodeFix(codeAction, context.Diagnostics); }
/// <inheritdoc/> public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var syntaxRoot = await document.GetSyntaxRootAsync(context.CancellationToken) .ConfigureAwait(false); var semanticModel = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); foreach (var diagnostic in context.Diagnostics) { var token = syntaxRoot.FindToken(diagnostic.Location.SourceSpan.Start); if (string.IsNullOrEmpty(token.ValueText)) { continue; } var node = syntaxRoot.FindNode(diagnostic.Location.SourceSpan); if (node == null || node.IsMissing) { continue; } var property = semanticModel.SemanticModelFor(node) .GetDeclaredSymbol(node, context.CancellationToken) as IPropertySymbol; if (ClrProperty.TryGetRegisteredName( property, semanticModel, context.CancellationToken, out string registeredName)) { context.RegisterCodeFix( CodeAction.Create( $"Rename to: {registeredName}.", _ => ApplyFixAsync(context, token, registeredName), this.GetType().FullName), diagnostic); } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); UsingDirectiveSyntax usingDirective = root .FindNode(context.Span, getInnermostNodeForTie: true)? .FirstAncestorOrSelf <UsingDirectiveSyntax>(); if (usingDirective == null) { return; } string name = usingDirective.Alias.Name.Identifier.ValueText; CodeAction codeAction = CodeAction.Create( "Inline alias expression", cancellationToken => RemoveUsingAliasDirectiveRefactoring.RefactorAsync(context.Document, usingDirective, cancellationToken), DiagnosticIdentifiers.AvoidUsageOfUsingAliasDirective + EquivalenceKeySuffix); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public override Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( new MyCodeAction( c => FixAllWithEditorAsync( context.Document, e => FixInCurrentMemberAsync( context.Document, e, context.Diagnostics[0], c ), c ) ), context.Diagnostics ); return(Task.CompletedTask); }
public async override Task RegisterCodeFixesAsync(CodeFixContext context) { foreach (var diagnostic in context.Diagnostics) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var token = root.FindToken(diagnostic.Location.SourceSpan.Start); if (!IsCatchDeclarationIdentifier(token)) { var ancestor = token.GetAncestor <TLocalDeclarationStatement>(); if (ancestor == null) { return; } } } context.RegisterCodeFix( new MyCodeAction(c => FixAsync(context.Document, context.Diagnostics.First(), c)), context.Diagnostics); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false); if (!TryFindFirstAncestorOrSelf(root, context.Span, out MemberAccessExpressionSyntax memberAccess)) { return; } CodeAction codeAction = CodeAction.Create( $"Use \"\" instead of '{memberAccess}'", cancellationToken => { return(UseEmptyStringLiteralInsteadOfStringEmptyRefactoring.RefactorAsync( context.Document, memberAccess, cancellationToken)); }, GetEquivalenceKey(DiagnosticIdentifiers.UseEmptyStringLiteralInsteadOfStringEmpty)); context.RegisterCodeFix(codeAction, context.Diagnostics); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var syntaxRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken) .ConfigureAwait(false); foreach (var diagnostic in context.Diagnostics) { if (syntaxRoot?.FindNode(diagnostic.Location.SourceSpan) is LiteralExpressionSyntax literal) { context.RegisterCodeFix( CodeAction.Create( "Prefix with $", _ => Task.FromResult( context.Document.WithSyntaxRoot( syntaxRoot.ReplaceNode( literal, CreateInterpolatedStringExpression(literal)))), "Prefix with $"), diagnostic); } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var span = context.Span; var diagnostics = context.Diagnostics; var cancellationToken = context.CancellationToken; var project = document.Project; var diagnostic = diagnostics.First(); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var node = root.FindToken(span.Start).GetAncestors<SyntaxNode>().First(n => n.Span.Contains(span)); using (Logger.LogBlock(FunctionId.Refactoring_FullyQualify, cancellationToken)) { // Has to be a simple identifier or generic name. if (node != null && CanFullyQualify(diagnostic, ref node)) { var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var matchingTypes = await this.GetMatchingTypesAsync(project, semanticModel, node, cancellationToken).ConfigureAwait(false); var matchingNamespaces = await this.GetMatchingNamespacesAsync(project, semanticModel, node, cancellationToken).ConfigureAwait(false); if (matchingTypes != null || matchingNamespaces != null) { matchingTypes = matchingTypes ?? SpecializedCollections.EmptyEnumerable<ISymbol>(); matchingNamespaces = matchingNamespaces ?? SpecializedCollections.EmptyEnumerable<ISymbol>(); var matchingTypeContainers = FilterAndSort(GetContainers(matchingTypes, semanticModel.Compilation)); var matchingNamespaceContainers = FilterAndSort(GetContainers(matchingNamespaces, semanticModel.Compilation)); var proposedContainers = matchingTypeContainers.Concat(matchingNamespaceContainers) .Distinct() .Take(MaxResults); var displayService = project.LanguageServices.GetService<ISymbolDisplayService>(); foreach (var container in proposedContainers) { var containerName = displayService.ToMinimalDisplayString(semanticModel, node.SpanStart, container); var syntaxFacts = document.Project.LanguageServices.GetService<ISyntaxFactsService>(); string name; int arity; syntaxFacts.GetNameAndArityOfSimpleName(node, out name, out arity); // Actual member name might differ by case. string memberName; if (this.IgnoreCase) { var member = container.GetMembers(name).FirstOrDefault(); memberName = member != null ? member.Name : name; } else { memberName = name; } var codeAction = new MyCodeAction( $"{containerName}.{memberName}", c => ProcessNode(document, node, containerName, c)); context.RegisterCodeFix(codeAction, diagnostic); } } } } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var span = context.Span; var diagnostics = context.Diagnostics; var cancellationToken = context.CancellationToken; var project = document.Project; var diagnostic = diagnostics.First(); var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var ancestors = root.FindToken(span.Start, findInsideTrivia: true).GetAncestors<SyntaxNode>(); if (!ancestors.Any()) { return; } var node = ancestors.FirstOrDefault(n => n.Span.Contains(span) && n != root); if (node == null) { return; } var placeSystemNamespaceFirst = document.Project.Solution.Workspace.Options.GetOption(Microsoft.CodeAnalysis.Shared.Options.OrganizerOptions.PlaceSystemNamespaceFirst, document.Project.Language); using (Logger.LogBlock(FunctionId.Refactoring_AddImport, cancellationToken)) { if (!cancellationToken.IsCancellationRequested) { if (this.CanAddImport(node, cancellationToken)) { var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var containingType = semanticModel.GetEnclosingNamedType(node.SpanStart, cancellationToken); var containingTypeOrAssembly = containingType ?? (ISymbol)semanticModel.Compilation.Assembly; var namespacesInScope = this.GetNamespacesInScope(semanticModel, node, cancellationToken); var syntaxFacts = document.Project.LanguageServices.GetService<ISyntaxFactsService>(); var matchingTypesNamespaces = await this.GetNamespacesForMatchingTypesAsync(project, diagnostic, node, semanticModel, namespacesInScope, syntaxFacts, cancellationToken).ConfigureAwait(false); var matchingTypes = await this.GetMatchingTypesAsync(project, diagnostic, node, semanticModel, namespacesInScope, syntaxFacts, cancellationToken).ConfigureAwait(false); var matchingNamespaces = await this.GetNamespacesForMatchingNamespacesAsync(project, diagnostic, node, semanticModel, namespacesInScope, syntaxFacts, cancellationToken).ConfigureAwait(false); var matchingExtensionMethodsNamespaces = await this.GetNamespacesForMatchingExtensionMethodsAsync(project, diagnostic, node, semanticModel, namespacesInScope, syntaxFacts, cancellationToken).ConfigureAwait(false); var matchingFieldsAndPropertiesAsync = await this.GetNamespacesForMatchingFieldsAndPropertiesAsync(project, diagnostic, node, semanticModel, namespacesInScope, syntaxFacts, cancellationToken).ConfigureAwait(false); var queryPatternsNamespaces = await this.GetNamespacesForQueryPatternsAsync(project, diagnostic, node, semanticModel, namespacesInScope, cancellationToken).ConfigureAwait(false); if (matchingTypesNamespaces != null || matchingNamespaces != null || matchingExtensionMethodsNamespaces != null || matchingFieldsAndPropertiesAsync != null || queryPatternsNamespaces != null || matchingTypes != null) { matchingTypesNamespaces = matchingTypesNamespaces ?? SpecializedCollections.EmptyList<INamespaceSymbol>(); matchingNamespaces = matchingNamespaces ?? SpecializedCollections.EmptyList<INamespaceSymbol>(); matchingExtensionMethodsNamespaces = matchingExtensionMethodsNamespaces ?? SpecializedCollections.EmptyList<INamespaceSymbol>(); matchingFieldsAndPropertiesAsync = matchingFieldsAndPropertiesAsync ?? SpecializedCollections.EmptyList<INamespaceSymbol>(); queryPatternsNamespaces = queryPatternsNamespaces ?? SpecializedCollections.EmptyList<INamespaceSymbol>(); matchingTypes = matchingTypes ?? SpecializedCollections.EmptyList<ITypeSymbol>(); var proposedImports = matchingTypesNamespaces.Cast<INamespaceOrTypeSymbol>() .Concat(matchingNamespaces.Cast<INamespaceOrTypeSymbol>()) .Concat(matchingExtensionMethodsNamespaces.Cast<INamespaceOrTypeSymbol>()) .Concat(matchingFieldsAndPropertiesAsync.Cast<INamespaceOrTypeSymbol>()) .Concat(queryPatternsNamespaces.Cast<INamespaceOrTypeSymbol>()) .Concat(matchingTypes.Cast<INamespaceOrTypeSymbol>()) .Distinct() .Where(NotNull) .Where(NotGlobalNamespace) .OrderBy(INamespaceOrTypeSymbolExtensions.CompareNamespaceOrTypeSymbols) .Take(8) .ToList(); if (proposedImports.Count > 0) { cancellationToken.ThrowIfCancellationRequested(); foreach (var import in proposedImports) { var action = new MyCodeAction(this.GetDescription(import, semanticModel, node), (c) => this.AddImportAsync(node, import, document, placeSystemNamespaceFirst, cancellationToken)); context.RegisterCodeFix(action, diagnostic); } } } } } } }