private static Solution UpdateMainDocument(Document document, SyntaxNode root, MethodDeclarationSyntax method, IEnumerable<IGrouping<Document, ReferenceLocation>> documentGroups)
{
var mainDocGroup = documentGroups.FirstOrDefault(dg => dg.Key.Equals(document));
SyntaxNode newRoot;
if (mainDocGroup == null)
{
newRoot = root.ReplaceNode(method, method.AddModifiers(staticToken));
}
else
{
var diagnosticNodes = mainDocGroup.Select(referenceLocation => root.FindNode(referenceLocation.Location.SourceSpan)).ToList();
newRoot = root.TrackNodes(diagnosticNodes.Union(new[] { method }));
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(method), method.AddModifiers(staticToken));
foreach (var diagnosticNode in diagnosticNodes)
{
var token = newRoot.FindToken(diagnosticNode.GetLocation().SourceSpan.Start);
var tokenParent = token.Parent;
if (token.Parent.IsKind(SyntaxKind.IdentifierName)) continue;
var invocationExpression = newRoot.GetCurrentNode(diagnosticNode).FirstAncestorOrSelfOfType<InvocationExpressionSyntax>()?.Expression;
if (invocationExpression == null || invocationExpression.IsKind(SyntaxKind.IdentifierName)) continue;
var memberAccess = invocationExpression as MemberAccessExpressionSyntax;
if (memberAccess == null) continue;
var newMemberAccessParent = memberAccess.Parent.ReplaceNode(memberAccess, memberAccess.Name)
.WithAdditionalAnnotations(Formatter.Annotation);
newRoot = newRoot.ReplaceNode(memberAccess.Parent, newMemberAccessParent);
}
}
var newSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
return newSolution;
}
private static SyntaxNode CreateNewLiteral(LiteralExpressionSyntax literal, SyntaxNode root)
{
SyntaxNode newRoot;
if (literal.Token.ValueText != literal.Token.Text)
{
var newTokenText = literal.Token.ValueText;
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
else
{
var value = (dynamic)literal.Token.Value;
if (literal.Parent != null && literal.Parent.IsKind(SyntaxKind.UnaryMinusExpression))
{
var newTokenText = (string)("0x" + (value * -1).ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText))
.WithLeadingTrivia(literal.Parent.GetLeadingTrivia())
.WithTrailingTrivia(literal.Parent.GetTrailingTrivia());
newRoot = root.ReplaceNode(literal.Parent, newLiteral);
}
else
{
var newTokenText = (string)("0x" + value.ToString("X"));
var newLiteral = literal.WithToken(SyntaxFactory.ParseToken(newTokenText));
newRoot = root.ReplaceNode(literal, newLiteral);
}
}
return newRoot;
}
private Task<Solution> UseExpressionBodiedMemberAsync(Document document, SyntaxNode root, SyntaxNode statement)
{
var returnStatement = (ReturnStatementSyntax) statement;
var expression = returnStatement.Expression;
var arrowClause = SyntaxFactory.ArrowExpressionClause(expression);
var property = statement.AncestorsAndSelf().OfType<PropertyDeclarationSyntax>().FirstOrDefault();
if (property != null)
{
var newProperty = property.RemoveNode(property.AccessorList, SyntaxRemoveOptions.KeepNoTrivia)
.WithExpressionBody(arrowClause)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
root = root.ReplaceNode(property, newProperty);
}
var method = statement.AncestorsAndSelf().OfType<MethodDeclarationSyntax>().FirstOrDefault();
if (method != null)
{
root = root.ReplaceNode(method, method.RemoveNode(method.Body, SyntaxRemoveOptions.KeepNoTrivia)
.WithExpressionBody(arrowClause)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
return Task.FromResult(document.WithSyntaxRoot(root).Project.Solution);
}
private static SyntaxNode CalculateNewRoot(SyntaxNode root, IfStatementSyntax ifStatement)
{
SyntaxNode newRoot;
var isTrue = ifStatement.Condition.IsKind(SyntaxKind.TrueLiteralExpression);
if (isTrue)
{
var block = ifStatement.Statement as BlockSyntax;
newRoot = block == null
? root.ReplaceNode(ifStatement, ifStatement.Statement)
: root.ReplaceNode(ifStatement, block.Statements);
}
else
{
if (ifStatement.Else == null)
{
newRoot = root.RemoveNode(ifStatement, SyntaxRemoveOptions.KeepNoTrivia);
}
else
{
var block = ifStatement.Else.Statement as BlockSyntax;
newRoot = block == null
? root.ReplaceNode(ifStatement, ifStatement.Else.Statement)
: root.ReplaceNode(ifStatement, block.Statements);
}
}
return newRoot.WithAdditionalAnnotations(Formatter.Annotation);
}
private static SyntaxNode ReplaceInvocation(InvocationExpressionSyntax invocation, ExpressionSyntax newInvocation, SyntaxNode root)
{
if (invocation.Parent.IsKind(SyntaxKind.LogicalNotExpression))
return root.ReplaceNode(invocation.Parent, newInvocation);
var negatedInvocation = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, newInvocation);
var newRoot = root.ReplaceNode(invocation, negatedInvocation);
return newRoot;
}
private static SyntaxNode ReplaceInvocation(InvocationExpressionSyntax invocation, ExpressionSyntax newInvocation, SyntaxNode root)
{
ExpressionSyntax lastExpression = invocation;
while (lastExpression.Parent is ExpressionSyntax)
lastExpression = (ExpressionSyntax)lastExpression.Parent;
var lastExpressionWithNewInvocation = lastExpression.ReplaceNode(invocation, newInvocation);
if (lastExpression.IsKind(SyntaxKind.LogicalNotExpression))
return root.ReplaceNode(lastExpression, ((PrefixUnaryExpressionSyntax)lastExpressionWithNewInvocation).Operand);
var negatedLastExpression = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, lastExpressionWithNewInvocation);
var newRoot = root.ReplaceNode(lastExpression, negatedLastExpression);
return newRoot;
}
private Task<Document> ConvertToInterpolatedString(Document document, SyntaxNode root, InvocationExpressionSyntax invocation, CancellationToken cancellationToken)
{
string previousString = null;
var parts = new List<InterpolatedStringContentSyntax>(invocation.ArgumentList.Arguments.Count);
for (int i = 0; i < invocation.ArgumentList.Arguments.Count; i++)
{
ArgumentSyntax argument = invocation.ArgumentList.Arguments[i];
var literal = argument.Expression as LiteralExpressionSyntax;
if (literal?.IsKind(SyntaxKind.StringLiteralExpression) ?? false)
{
//strings needs to be collapsed, otherwise VS will insert additional whitespaces
previousString += literal.Token.Text.Substring(1, literal.Token.Text.Length - 2);
}
else
{
if (previousString != null)
{
parts.Add(InterpolatedStringGenerator.TextPart(previousString));
previousString = null;
}
parts.Add(InterpolatedStringGenerator.ExpressionPart(argument.Expression.WithoutLeadingTrivia().WithoutTrailingTrivia()));
}
}
if (previousString != null)
{
parts.Add(InterpolatedStringGenerator.TextPart(previousString));
}
SyntaxNode interpolated = InterpolatedStringGenerator.InterpolatedString(parts);
root = root.ReplaceNode(invocation, interpolated);
return Task.FromResult(document.WithSyntaxRoot(root));
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var attribute = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as AttributeSyntax;
var attributeList = attribute?.Parent as AttributeListSyntax;
if (attribute == null ||
attributeList == null)
{
return;
}
var semanticModel = await context.Document.GetSemanticModelAsync().ConfigureAwait(false);
var optionalAttribute = semanticModel?.Compilation?.GetTypeByMetadataName(
KnownType.System_Runtime_InteropServices_OptionalAttribute.TypeName);
if (optionalAttribute == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newRoot = root.ReplaceNode(
attributeList,
GetNewAttributeList(attributeList, optionalAttribute, semanticModel));
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
private Task<Solution> MakePublicAsync(Document document, SyntaxNode root, MethodDeclarationSyntax method)
{
var generator = SyntaxGenerator.GetGenerator(document);
var newMethod = generator.WithAccessibility(method, Accessibility.Public);
var newRoot = root.ReplaceNode(method, newMethod);
return Task.FromResult(document.WithSyntaxRoot(newRoot).Project.Solution);
}
private Task<Solution> RemoveRethrowAsync(Document document, SyntaxNode root, ThrowStatementSyntax throwStatement)
{
var newStatement = SyntaxFactory.ThrowStatement();
var newRoot = root.ReplaceNode(throwStatement, newStatement);
var newDocument = document.WithSyntaxRoot(newRoot);
return Task.FromResult(newDocument.Project.Solution);
}
internal override Task<Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, string diagnosticId, CancellationToken cancellationToken)
{
//// We are going to implement IDisposable interface:
////
//// public void Dispose()
//// {
//// throw new NotImplementedException();
//// }
var syntaxNode = nodeToFix as ClassDeclarationSyntax;
if (syntaxNode == null)
{
return Task.FromResult(document);
}
var statement = CreateThrowNotImplementedStatement(model);
if (statement == null)
{
return Task.FromResult(document);
}
var member = CreateSimpleMethodDeclaration(CA1001DiagnosticAnalyzer.Dispose, statement);
var newNode =
syntaxNode.BaseList != null ?
syntaxNode.AddBaseListTypes(SyntaxFactory.ParseTypeName(CA1001DiagnosticAnalyzer.IDisposable)).AddMembers(new[] { member }) :
syntaxNode.AddBaseListTypes(SyntaxFactory.ParseTypeName(CA1001DiagnosticAnalyzer.IDisposable)).AddMembers(new[] { member }).WithIdentifier(syntaxNode.Identifier.WithTrailingTrivia(SyntaxFactory.Space));
newNode = newNode.WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(nodeToFix, newNode)));
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var prefix = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as PrefixUnaryExpressionSyntax;
if (prefix == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
ExpressionSyntax expression;
uint count;
GetExpression(prefix, out expression, out count);
if (count%2 == 1)
{
expression = SyntaxFactory.PrefixUnaryExpression(
prefix.Kind(),
expression);
}
var newRoot = root.ReplaceNode(prefix, expression
.WithAdditionalAnnotations(Formatter.Annotation));
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
static Document PerformAction(Document document, SyntaxNode root, InvocationExpressionSyntax invocationNode)
{
var arg = invocationNode.ArgumentList.Arguments.Select(a => a.Expression).First();
if (!arg.DescendantNodesAndSelf().OfType<BinaryExpressionSyntax>().All(bop => bop.IsKind(SyntaxKind.BitwiseOrExpression)))
return document;
arg = ConvertBitwiseFlagComparisonToHasFlagsCodeRefactoringProvider.MakeFlatExpression(arg, SyntaxKind.BitwiseAndExpression);
if (arg is BinaryExpressionSyntax)
arg = SyntaxFactory.ParenthesizedExpression(arg);
SyntaxNode nodeToReplace = invocationNode;
while (nodeToReplace.Parent is ParenthesizedExpressionSyntax)
nodeToReplace = nodeToReplace.Parent;
bool negateHasFlags = nodeToReplace.Parent != null && nodeToReplace.Parent.IsKind(SyntaxKind.LogicalNotExpression);
if (negateHasFlags)
nodeToReplace = nodeToReplace.Parent;
var expr = SyntaxFactory.BinaryExpression(
negateHasFlags ? SyntaxKind.EqualsExpression : SyntaxKind.NotEqualsExpression,
SyntaxFactory.ParenthesizedExpression(SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseAndExpression, ((MemberAccessExpressionSyntax)invocationNode.Expression).Expression, arg))
.WithAdditionalAnnotations(Formatter.Annotation),
SyntaxFactory.ParseExpression("0")
);
var newRoot = root.ReplaceNode((SyntaxNode)
nodeToReplace,
expr.WithAdditionalAnnotations(Formatter.Annotation)
);
return document.WithSyntaxRoot(newRoot);
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var literal = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as LiteralExpressionSyntax;
if (literal == null)
{
return;
}
var newLiteral = SyntaxFactory.Literal(
literal.Token.Text.ToUpperInvariant(),
(long)literal.Token.Value);
if (!newLiteral.IsKind(SyntaxKind.None))
{
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newRoot = root.ReplaceNode(literal,
literal.WithToken(newLiteral).WithTriviaFrom(literal));
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 syntaxNode = root.FindNode(diagnosticSpan, getInnermostNodeForTie: true) as PrefixUnaryExpressionSyntax;
if (syntaxNode == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var expression = syntaxNode.Operand.RemoveParentheses();
var newBinary = ChangeOperator((BinaryExpressionSyntax)expression);
if (syntaxNode.Parent is ExpressionSyntax &&
!ExpressionTypesWithNoParens.Any(type => type.IsInstanceOfType(syntaxNode.Parent)))
{
newBinary = SyntaxFactory.ParenthesizedExpression(newBinary);
}
var newRoot = root.ReplaceNode(
syntaxNode,
newBinary.WithAdditionalAnnotations(Formatter.Annotation));
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
private static async Task<Document> RemoveEmptyStatementAsync(Document document, SyntaxNode root, EmptyStatementSyntax node, CancellationToken cancellationToken)
{
SyntaxNode newRoot;
switch (node.Parent.Kind())
{
case SyntaxKind.Block:
case SyntaxKind.SwitchSection:
// empty statements in a block or switch section can be removed
return await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false);
case SyntaxKind.IfStatement:
case SyntaxKind.ElseClause:
case SyntaxKind.ForStatement:
case SyntaxKind.WhileStatement:
case SyntaxKind.DoStatement:
// these cases are always replaced with an empty block
newRoot = root.ReplaceNode(node, SyntaxFactory.Block().WithTriviaFrom(node));
return document.WithSyntaxRoot(newRoot);
case SyntaxKind.LabeledStatement:
// handle this case as a text manipulation for simplicity
return await RemoveSemicolonTextAsync(document, node.SemicolonToken, cancellationToken).ConfigureAwait(false);
default:
return document;
}
}
protected IEnumerable<CodeAction> GetActions(Document document, SemanticModel semanticModel, SyntaxNode root, TextSpan span, ParameterSyntax node)
{
if (!node.Identifier.Span.Contains(span))
yield break;
var parameter = node;
var bodyStatement = parameter.Parent.Parent.ChildNodes().OfType<BlockSyntax>().FirstOrDefault();
if (bodyStatement == null)
yield break;
var parameterSymbol = semanticModel.GetDeclaredSymbol(node);
var type = parameterSymbol.Type;
if (type == null || type.IsValueType || HasNotNullContract(semanticModel, parameterSymbol, bodyStatement))
yield break;
yield return CreateAction(
node.Identifier.Span
, t2 => {
var newBody = bodyStatement.WithStatements(SyntaxFactory.List<StatementSyntax>(new[] { CreateContractRequiresCall(node.Identifier.ToString()) }.Concat(bodyStatement.Statements)));
var newRoot = (CompilationUnitSyntax)root.ReplaceNode((SyntaxNode)bodyStatement, newBody);
if (UsingStatementNotPresent(newRoot)) newRoot = AddUsingStatement(node, newRoot);
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
, "Add contract requiring parameter must not be null"
);
}
public static SyntaxNode IntroduceFieldFromConstructor(SyntaxNode root, ConstructorDeclarationSyntax constructorStatement, ParameterSyntax parameter)
{
var oldClass = constructorStatement.FirstAncestorOrSelf<ClassDeclarationSyntax>();
var newClass = oldClass;
var fieldName = parameter.Identifier.ValueText;
var fieldType = parameter.Type;
var members = ExtractMembersFromClass(oldClass.Members);
var addMember = false;
if (!members.Any(p => p.Key == fieldName && p.Value == fieldType.ToString()))
{
var identifierPostFix = 0;
while (members.Any(p => p.Key == fieldName))
fieldName = parameter.Identifier.ValueText + ++identifierPostFix;
addMember = true;
}
var assignmentField = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(fieldName)), SyntaxFactory.IdentifierName(parameter.Identifier.ValueText)));
var newConstructor = constructorStatement.WithBody(constructorStatement.Body.AddStatements(assignmentField));
newClass = newClass.ReplaceNode(constructorStatement, newConstructor);
if (addMember)
{
var newField = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(parameter.Type)
.WithVariables(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(fieldName)))))
.WithModifiers(SyntaxFactory.TokenList(new[] { SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword) }))
.WithAdditionalAnnotations(Formatter.Annotation);
newClass = newClass.WithMembers(newClass.Members.Insert(0, newField)).WithoutAnnotations(Formatter.Annotation);
}
var newRoot = root.ReplaceNode(oldClass, newClass);
return newRoot;
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var syntaxNode = root.FindNode(diagnosticSpan);
var variableDeclarator = syntaxNode.FirstAncestorOrSelf<VariableDeclaratorSyntax>();
var variableDeclaration = variableDeclarator?.Parent as VariableDeclarationSyntax;
if (variableDeclaration == null)
{
return;
}
if (variableDeclaration.Variables.Count == 1)
{
var fieldDeclaration = variableDeclaration.Parent as FieldDeclarationSyntax;
if (fieldDeclaration == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newFieldDeclaration = fieldDeclaration.AddModifiers(
SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
var newRoot = root.ReplaceNode(fieldDeclaration, newFieldDeclaration);
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 paramsToken = root.FindToken(diagnosticSpan.Start);
if (!paramsToken.IsKind(SyntaxKind.ParamsKeyword))
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var node = paramsToken.Parent;
var newNode = node.ReplaceToken(
paramsToken,
SyntaxFactory.Token(SyntaxKind.None));
newNode = newNode.WithTriviaFrom(node);
var newRoot = root.ReplaceNode(node, newNode);
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
public async static Task<Solution> MakeAutoPropertyAsync(Document document, SyntaxNode root, PropertyDeclarationSyntax property, CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var getterReturn = (ReturnStatementSyntax)property.AccessorList.Accessors.First(a => a.Keyword.ValueText == "get").Body.Statements.First();
var returnIdentifier = (IdentifierNameSyntax)(getterReturn.Expression is MemberAccessExpressionSyntax ? ((MemberAccessExpressionSyntax)getterReturn.Expression).Name : getterReturn.Expression);
var returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
var variableDeclarator = (VariableDeclaratorSyntax)returnIdentifierSymbol.DeclaringSyntaxReferences.First().GetSyntax();
var fieldDeclaration = variableDeclarator.FirstAncestorOfType<FieldDeclarationSyntax>();
root = root.TrackNodes(returnIdentifier, fieldDeclaration, property);
document = document.WithSyntaxRoot(root);
root = await document.GetSyntaxRootAsync(cancellationToken);
semanticModel = await document.GetSemanticModelAsync(cancellationToken);
returnIdentifier = root.GetCurrentNode(returnIdentifier);
returnIdentifierSymbol = semanticModel.GetSymbolInfo(returnIdentifier).Symbol;
var newProperty = GetSimpleProperty(property, variableDeclarator)
.WithTriviaFrom(property)
.WithAdditionalAnnotations(Formatter.Annotation);
var newSolution = await Renamer.RenameSymbolAsync(document.Project.Solution, returnIdentifierSymbol, property.Identifier.ValueText, document.Project.Solution.Workspace.Options, cancellationToken);
document = newSolution.GetDocument(document.Id);
root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
root = root.InsertNodesAfter(root.GetCurrentNode(property), new[] { newProperty });
var multipleVariableDeclaration = fieldDeclaration.Declaration.Variables.Count > 1;
if (multipleVariableDeclaration)
{
var newfieldDeclaration = fieldDeclaration.WithDeclaration(fieldDeclaration.Declaration.RemoveNode(variableDeclarator, SyntaxRemoveOptions.KeepNoTrivia));
root = root.RemoveNode(root.GetCurrentNode<SyntaxNode>(property), SyntaxRemoveOptions.KeepNoTrivia);
root = root.ReplaceNode(root.GetCurrentNode(fieldDeclaration), newfieldDeclaration);
}
else
{
root = root.RemoveNodes(root.GetCurrentNodes<SyntaxNode>(new SyntaxNode[] { fieldDeclaration, property }), SyntaxRemoveOptions.KeepNoTrivia);
}
document = document.WithSyntaxRoot(root);
return document.Project.Solution;
}
private static void AddCodeFixWithNewPublicConstructor(CodeFixContext context, SyntaxNode root,
Diagnostic diagnostic, ClassDeclarationSyntax classNode)
{
// Generated from http://roslynquoter.azurewebsites.net/
var constructor = SyntaxFactory.ConstructorDeclaration(classNode.Identifier)
.WithModifiers(
SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword)))
.WithParameterList(SyntaxFactory.ParameterList()
.WithOpenParenToken(
SyntaxFactory.Token(SyntaxKind.OpenParenToken))
.WithCloseParenToken(
SyntaxFactory.Token(
SyntaxKind.CloseParenToken)))
.WithBody(SyntaxFactory.Block()
.WithOpenBraceToken(
SyntaxFactory.Token(
SyntaxKind.OpenBraceToken))
.WithCloseBraceToken(
SyntaxFactory.Token(
SyntaxKind.CloseBraceToken))).NormalizeWhitespace().WithAdditionalAnnotations(Formatter.Annotation);
var newClassNode = classNode.AddMembers(constructor);
var newRoot = root.ReplaceNode(classNode, newClassNode);
context.RegisterCodeFix(
CodeAction.Create(
CheckConstructorsAnalyzerPublicConstructorCodeFixConstants.AddPublicConstructorDescription,
_ => Task.FromResult(context.Document.WithSyntaxRoot(newRoot)),
CheckConstructorsAnalyzerPublicConstructorCodeFixConstants.AddPublicConstructorDescription), diagnostic);
}
protected sealed override async Task RegisterCodeFixesAsync(SyntaxNode root, CodeFixContext context)
{
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
var nameEquals = root.FindNode(diagnosticSpan) as NameEqualsSyntax;
var anonymousObjectCreation = nameEquals?.Parent?.Parent as AnonymousObjectCreationExpressionSyntax;
if (anonymousObjectCreation == null)
{
return;
}
context.RegisterCodeFix(
CodeAction.Create(
Title,
c =>
{
var newInitializersWithSeparators = anonymousObjectCreation.Initializers.GetWithSeparators()
.Select(item => GetNewSyntaxListItem(item));
var newAnonymousObjectCreation = anonymousObjectCreation
.WithInitializers(SyntaxFactory.SeparatedList<AnonymousObjectMemberDeclaratorSyntax>(newInitializersWithSeparators))
.WithTriviaFrom(anonymousObjectCreation);
var newRoot = root.ReplaceNode(
anonymousObjectCreation,
newAnonymousObjectCreation);
return Task.FromResult(context.Document.WithSyntaxRoot(newRoot));
}),
context.Diagnostics);
}
private Task<Solution> SimplifyExpressionAsync(Document document, SyntaxNode root, SyntaxNode statement)
{
var trueLiteralExpression = (LiteralExpressionSyntax) statement;
var binaryExpression = (BinaryExpressionSyntax) trueLiteralExpression.Parent;
SyntaxNode newRoot;
if (binaryExpression.Left == trueLiteralExpression)
{
newRoot = root.ReplaceNode(binaryExpression, binaryExpression.Right).WithAdditionalAnnotations(Formatter.Annotation);
}
else
{
newRoot = root.ReplaceNode(binaryExpression, binaryExpression.Left).WithAdditionalAnnotations(Formatter.Annotation);
}
var newDocument = document.WithSyntaxRoot(newRoot);
return Task.FromResult(newDocument.Project.Solution);
}
private static SyntaxNode AddAttribute(SyntaxNode root, ClassDeclarationSyntax classNode,
string name)
{
var attribute = SyntaxFactory.Attribute(SyntaxFactory.ParseName(name));
var attributeList = SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList<AttributeSyntax>().Add(attribute));
var newClassNode = classNode.AddAttributeLists(attributeList);
return root.ReplaceNode(classNode, newClassNode);
}
private Task<Solution> RemoveConditionalAsync(Document document, SyntaxNode root, SyntaxNode statement)
{
var conditionalExpression = (ConditionalExpressionSyntax) statement;
var newRoot = root.ReplaceNode(conditionalExpression, conditionalExpression.Condition).WithAdditionalAnnotations(Formatter.Annotation);
var newDocument = document.WithSyntaxRoot(newRoot);
return Task.FromResult(newDocument.Project.Solution);
}
private static Task<Document> AddJustificationToAttributeAsync(Document document, SyntaxNode syntaxRoot, AttributeSyntax attribute)
{
var attributeName = SyntaxFactory.IdentifierName(nameof(SuppressMessageAttribute.Justification));
var newArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(attributeName), null, GetNewAttributeValue());
var newArgumentList = attribute.ArgumentList.AddArguments(newArgument);
return Task.FromResult(document.WithSyntaxRoot(syntaxRoot.ReplaceNode(attribute.ArgumentList, newArgumentList)));
}
internal static SyntaxNode ComputeExpression(SyntaxNode nodeToReplace, BinaryExpressionSyntax expression, SyntaxNode root, SemanticModel semanticModel)
{
var result = semanticModel.GetConstantValue(expression);
if (!result.HasValue) return null;
var newExpression = SyntaxFactory.ParseExpression(System.Convert.ToString(result.Value, System.Globalization.CultureInfo.InvariantCulture));
var newRoot = root.ReplaceNode(nodeToReplace, newExpression);
return newRoot;
}
protected override async Task<Document> FixEquals(Document document, SyntaxGenerator generator, SyntaxNode root, SyntaxNode node, CancellationToken cancellationToken)
{
SemanticModel model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var binaryExpression = (BinaryExpressionSyntax)node;
SyntaxNode invocation = CreateEqualsExpression(generator, model, binaryExpression.Left, binaryExpression.Right, node.Kind() == SyntaxKind.EqualsExpression).WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = root.ReplaceNode(node, invocation);
return document.WithSyntaxRoot(newRoot);
}
static Document PerformAction(Document document, SyntaxNode root, BinaryExpressionSyntax bop)
{
var nodeToReplace = bop.IsParentKind(SyntaxKind.ParenthesizedExpression) ? bop.Parent : bop;
var castExpr = (ExpressionSyntax)SyntaxFactory.CastExpression(bop.Right as TypeSyntax, CSharpUtil.AddParensIfRequired(bop.Left.WithoutLeadingTrivia().WithoutTrailingTrivia())).WithLeadingTrivia(bop.GetLeadingTrivia()).WithTrailingTrivia(bop.GetTrailingTrivia());
var newRoot = root.ReplaceNode((SyntaxNode)nodeToReplace, castExpr);
return document.WithSyntaxRoot(newRoot);
}