1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
using System;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ILLink.CodeFixProvider;
using ILLink.RoslynAnalyzer;
using ILLink.Shared;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Simplification;
namespace ILLink.CodeFix
{
public class DAMCodeFixProvider : Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider
{
public static ImmutableArray<DiagnosticDescriptor> GetSupportedDiagnostics ()
{
var diagDescriptorsArrayBuilder = ImmutableArray.CreateBuilder<DiagnosticDescriptor> ();
diagDescriptorsArrayBuilder.Add (DiagnosticDescriptors.GetDiagnosticDescriptor (DiagnosticId.DynamicallyAccessedMembersMismatchParameterTargetsThisParameter));
diagDescriptorsArrayBuilder.Add (DiagnosticDescriptors.GetDiagnosticDescriptor (DiagnosticId.DynamicallyAccessedMembersMismatchFieldTargetsThisParameter));
return diagDescriptorsArrayBuilder.ToImmutable ();
}
public static ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => GetSupportedDiagnostics ();
public sealed override ImmutableArray<string> FixableDiagnosticIds => SupportedDiagnostics.Select (dd => dd.Id).ToImmutableArray ();
private protected static LocalizableString CodeFixTitle => new LocalizableResourceString (nameof (Resources.DynamicallyAccessedMembersCodeFixTitle), Resources.ResourceManager, typeof (Resources));
private protected static string FullyQualifiedAttributeName => DynamicallyAccessedMembersAnalyzer.FullyQualifiedDynamicallyAccessedMembersAttribute;
protected static SyntaxNode[] GetAttributeArguments (ISymbol targetSymbol, SyntaxGenerator syntaxGenerator, Diagnostic diagnostic)
{
object id = Enum.Parse (typeof (DiagnosticId), diagnostic.Id.Substring (2));
switch (id) {
case DiagnosticId.DynamicallyAccessedMembersMismatchParameterTargetsThisParameter:
return new[] { syntaxGenerator.AttributeArgument (syntaxGenerator.TypedConstantExpression (targetSymbol.GetAttributes ().First (attr => attr.AttributeClass?.ToDisplayString () == DynamicallyAccessedMembersAnalyzer.FullyQualifiedDynamicallyAccessedMembersAttribute).ConstructorArguments[0])) };
case DiagnosticId.DynamicallyAccessedMembersMismatchFieldTargetsThisParameter:
return new[] { syntaxGenerator.AttributeArgument (syntaxGenerator.TypedConstantExpression (targetSymbol.GetAttributes ().First (attr => attr.AttributeClass?.ToDisplayString () == DynamicallyAccessedMembersAnalyzer.FullyQualifiedDynamicallyAccessedMembersAttribute).ConstructorArguments[0])) };
default:
return Array.Empty<SyntaxNode> ();
}
}
public sealed override FixAllProvider GetFixAllProvider ()
{
// See https://github.com/dotnet/roslyn/blob/master/docs/analyzers/FixAllProvider.md for more information on Fix All Providers
return WellKnownFixAllProviders.BatchFixer;
}
public override async Task RegisterCodeFixesAsync (CodeFixContext context)
{
var document = context.Document;
if (await document.GetSyntaxRootAsync (context.CancellationToken).ConfigureAwait (false) is not { } root)
return;
var diagnostic = context.Diagnostics.First ();
SyntaxNode diagnosticNode = root.FindNode (diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
if (await document.GetSemanticModelAsync (context.CancellationToken).ConfigureAwait (false) is not { } model)
return;
// Note: We get the target symbol from the diagnostic location.
// This works when the diagnostic location is a method call, because the target symbol will be the called method with annotations, but won't work in general for other kinds of diagnostics.
if (model.GetSymbolInfo (diagnosticNode).Symbol is not { } targetSymbol)
return;
if (model.Compilation.GetTypeByMetadataName (FullyQualifiedAttributeName) is not { } attributeSymbol)
return;
if (diagnosticNode is not InvocationExpressionSyntax invocationExpression)
return;
var arguments = invocationExpression.ArgumentList.Arguments;
if (arguments.Count > 1)
return;
if (arguments.Count == 1) {
if (arguments[0].Expression is not LiteralExpressionSyntax literalSyntax
|| literalSyntax.Kind () is not SyntaxKind.StringLiteralExpression) {
return;
}
}
// N.B. May be null for FieldDeclaration, since field declarations can declare multiple variables
var attributableSymbol = (invocationExpression.Expression is MemberAccessExpressionSyntax simpleMember
&& simpleMember.Expression is IdentifierNameSyntax name) ? model.GetSymbolInfo (name).Symbol : null;
if (attributableSymbol is null)
return;
var attributableNodeList = attributableSymbol.DeclaringSyntaxReferences;
if (attributableNodeList.Length != 1)
return;
var attributableNode = attributableNodeList[0].GetSyntax ();
if (attributableNode is null) return;
var attributeArguments = GetAttributeArguments (targetSymbol, SyntaxGenerator.GetGenerator (document), diagnostic);
var codeFixTitle = CodeFixTitle.ToString ();
context.RegisterCodeFix (CodeAction.Create (
title: codeFixTitle,
createChangedDocument: ct => AddAttributeAsync (
document, attributableNode, attributeArguments, attributeSymbol, ct),
equivalenceKey: codeFixTitle), diagnostic);
}
private static async Task<Document> AddAttributeAsync (
Document document,
SyntaxNode targetNode,
SyntaxNode[] attributeArguments,
ITypeSymbol attributeSymbol,
CancellationToken cancellationToken)
{
var editor = await DocumentEditor.CreateAsync (document, cancellationToken).ConfigureAwait (false);
var generator = editor.Generator;
var attribute = generator.Attribute (
generator.TypeExpression (attributeSymbol), attributeArguments)
.WithAdditionalAnnotations (Simplifier.Annotation, Simplifier.AddImportsAnnotation);
editor.AddAttribute (targetNode, attribute);
return editor.GetChangedDocument ();
}
}
}
|
