public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Solution FixParameter(Document document, SyntaxNode root, ParameterSyntax declaration)
{
var replaced = root.ReplaceNode(declaration, declaration.ToRef());
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
Solution FixVariable(Document document, SyntaxNode root, VariableDeclarationSyntax declaration)
{
var replaced = root.ReplaceNode(declaration, declaration.ToRef());
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
Solution FixForEach(Document document, SyntaxNode root, ForEachStatementSyntax statement)
{
var replaced = root.ReplaceNode(statement.Type, statement.Type.ToRef());
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
await Task.WhenAll(
context.RegisterCodeAction <VariableDeclarationSyntax>("Add 'ref' modifier.", Variable.Rules.MissingVariableRef.Id, FixVariable),
context.RegisterCodeAction <ForEachStatementSyntax>("Add 'ref' modifier.", ForEach.Rules.MissingForeachRef.Id, FixForEach),
context.RegisterCodeAction <ParameterSyntax>("Add 'ref' modifier.", Parameter.Rules.MissingParameterRefOrIn.Id, FixParameter));
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
Solution FixVariable(Document document, SyntaxNode root, VariableDeclarationSyntax declaration)
{
var replaced = root.ReplaceNode(declaration, declaration.ToRef(true));
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
Solution FixForEach(Document document, SyntaxNode root, ForEachStatementSyntax statement)
{
var replaced = root.ReplaceNode(statement.Type, statement.Type.ToRef(true));
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
await context.RegisterCodeAction <VariableDeclarationSyntax>("Add 'ref readonly ' modifier.", Variable.Rules.MissingVariableRefReadonly.Id, FixVariable);
await context.RegisterCodeAction <ForEachStatementSyntax>("Add 'ref readonly ' modifier.", ForEach.Rules.MissingForeachRefReadonly.Id, FixForEach);
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
bool RequiresUsing(SemanticModel model, SyntaxNode root) =>
model.Compilation.GlobalNamespace?.Namespace(nameof(Entia))?.Namespace(nameof(Core)) is INamespaceSymbol @namespace &&
root.DescendantNodes().OfType <UsingDirectiveSyntax>().None(@using => model.GetSymbolInfo(@using.Name).Symbol == @namespace);
UsingDirectiveSyntax CreateUsing() => SyntaxFactory.UsingDirective(
SyntaxFactory.QualifiedName(
SyntaxFactory.IdentifierName(nameof(Entia)),
SyntaxFactory.IdentifierName(nameof(Core))));
SyntaxList <AttributeListSyntax> AddAttribute(in SyntaxList <AttributeListSyntax> lists)
{
var attribute = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Default"));
return(lists.Count > 0 ?
lists.Replace(lists[0], lists[0].AddAttributes(attribute)) :
lists.Add(SyntaxFactory.AttributeList().AddAttributes(attribute)));
}
async Task <Solution> FixField(Document document, CompilationUnitSyntax root, FieldDeclarationSyntax declaration, CancellationToken token)
{
var model = await document.GetSemanticModelAsync(token);
var replaced = root.ReplaceNode(declaration, declaration.WithAttributeLists(AddAttribute(declaration.AttributeLists)));
if (RequiresUsing(model, root))
{
replaced = replaced.AddUsings(CreateUsing());
}
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
async Task <Solution> FixProperty(Document document, CompilationUnitSyntax root, PropertyDeclarationSyntax declaration, CancellationToken token)
{
var model = await document.GetSemanticModelAsync(token);
var replaced = root.ReplaceNode(declaration, declaration.WithAttributeLists(AddAttribute(declaration.AttributeLists)));
if (RequiresUsing(model, root))
{
replaced = replaced.AddUsings(CreateUsing());
}
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
async Task <Solution> FixMethod(Document document, CompilationUnitSyntax root, MethodDeclarationSyntax declaration, CancellationToken token)
{
var model = await document.GetSemanticModelAsync(token);
var replaced = root.ReplaceNode(declaration, declaration.WithAttributeLists(AddAttribute(declaration.AttributeLists)));
if (RequiresUsing(model, root))
{
replaced = replaced.AddUsings(CreateUsing());
}
var solution = document.Project.Solution;
return(solution.WithDocumentSyntaxRoot(document.Id, replaced));
}
await context.RegisterCodeAction <FieldDeclarationSyntax>("Add 'Default' attribute.", NamedType.Rules.MissingDefaultAttribute.Id, FixField);
await context.RegisterCodeAction <PropertyDeclarationSyntax>("Add 'Default' attribute.", NamedType.Rules.MissingDefaultAttribute.Id, FixProperty);
await context.RegisterCodeAction <MethodDeclarationSyntax>("Add 'Default' attribute.", NamedType.Rules.MissingDefaultAttribute.Id, FixMethod);
}
public static async Task RegisterCodeAction <T>(this CodeFixContext context, string name, string identifier, Func <Document, CompilationUnitSyntax, T, Solution> action) where T : SyntaxNode => await context.RegisterCodeAction <T>(name, identifier, (document, root, node, _) => Task.FromResult(action?.Invoke(document, root, node)));