private static ImmutableArray <IfRefactoring> Analyze(
ExpressionStatementSyntax expressionStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(expressionStatement, out assignment))
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentStatement assignment1;
if (SimpleAssignmentStatement.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentStatement assignment2;
if (SimpleAssignmentStatement.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsEquivalentTo(assignment2.Left, topLevel: false) &&
assignment1.Left.IsEquivalentTo(assignment.Left, topLevel: false) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(expressionStatement.SpanStart, ifStatement.Span.End)))
{
return(new AssignmentAndIfElseToAssignmentWithConditionalExpression(expressionStatement, assignment.Right, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public static void AnalyzeLocalDeclarationStatement(SyntaxNodeAnalysisContext context)
{
var localDeclaration = (LocalDeclarationStatementSyntax)context.Node;
if (!localDeclaration.IsConst &&
!localDeclaration.ContainsDiagnostics &&
!localDeclaration.SpanOrTrailingTriviaContainsDirectives())
{
VariableDeclarationSyntax declaration = localDeclaration.Declaration;
if (declaration != null)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
if (variables.Count == 1)
{
StatementSyntax nextStatement = localDeclaration.NextStatement();
if (nextStatement?.ContainsDiagnostics == false &&
nextStatement?.SpanOrLeadingTriviaContainsDirectives() == false)
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(nextStatement, out assignment) &&
assignment.Left.IsKind(SyntaxKind.IdentifierName))
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
LocalInfo localInfo = FindInitializedVariable((IdentifierNameSyntax)assignment.Left, variables[0], semanticModel, cancellationToken);
if (localInfo.IsValid)
{
EqualsValueClauseSyntax initializer = localInfo.Declarator.Initializer;
ExpressionSyntax value = initializer?.Value;
if (value == null ||
(IsDefaultValue(declaration.Type, value, semanticModel, cancellationToken) &&
!IsReferenced(localInfo.Symbol, assignment.Right, semanticModel, cancellationToken)))
{
context.ReportDiagnostic(DiagnosticDescriptors.MergeLocalDeclarationWithAssignment, localInfo.Declarator.Identifier);
if (value != null)
{
context.ReportNode(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, initializer);
context.ReportToken(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, assignment.AssignmentExpression.OperatorToken);
}
context.ReportToken(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, localDeclaration.SemicolonToken);
context.ReportNode(DiagnosticDescriptors.MergeLocalDeclarationWithAssignmentFadeOut, assignment.Left);
}
}
}
}
}
}
}
}
private static bool IsSymbolAssignedInStatement(ISymbol symbol, StatementSyntax statement, SemanticModel semanticModel, CancellationToken cancellationToken)
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(statement, out assignment))
{
return(symbol.Equals(semanticModel.GetSymbol(assignment.Left, cancellationToken)));
}
return(false);
}
public static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
if (ifStatement.IsSimpleIf() &&
!ifStatement.ContainsDiagnostics)
{
SyntaxList <StatementSyntax> statements;
if (ifStatement.TryGetContainingList(out statements) &&
!IsPartOfLazyInitialization(ifStatement, statements))
{
EqualsToNullExpression equalsToNull;
if (EqualsToNullExpression.TryCreate(ifStatement.Condition, out equalsToNull))
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment) &&
SyntaxComparer.AreEquivalent(assignment.Left, equalsToNull.Left) &&
assignment.Right.IsSingleLine() &&
!ifStatement.SpanContainsDirectives())
{
int index = statements.IndexOf(ifStatement);
if (index > 0)
{
StatementSyntax previousStatement = statements[index - 1];
if (!previousStatement.ContainsDiagnostics &&
CanRefactor(previousStatement, ifStatement, equalsToNull.Left, ifStatement.Parent))
{
context.ReportDiagnostic(DiagnosticDescriptors.UseCoalesceExpression, previousStatement);
}
}
if (index < statements.Count - 1)
{
StatementSyntax nextStatement = statements[index + 1];
if (!nextStatement.ContainsDiagnostics)
{
MemberInvocationStatement memberInvocation;
if (MemberInvocationStatement.TryCreate(nextStatement, out memberInvocation) &&
SyntaxComparer.AreEquivalent(equalsToNull.Left, memberInvocation.Expression) &&
!ifStatement.Parent.ContainsDirectives(TextSpan.FromBounds(ifStatement.SpanStart, nextStatement.Span.End)))
{
context.ReportDiagnostic(DiagnosticDescriptors.InlineLazyInitialization, ifStatement);
}
}
}
}
}
}
}
}
private static ImmutableArray <IfRefactoring> Analyze(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
IfAnalysisOptions options)
{
VariableDeclaratorSyntax declarator = localDeclarationStatement
.Declaration?
.Variables
.SingleOrDefault(throwException: false);
if (declarator != null)
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause?.Statement?.IsKind(SyntaxKind.IfStatement) == false)
{
SimpleAssignmentStatement assignment1;
if (SimpleAssignmentStatement.TryCreate(ifStatement.GetSingleStatementOrDefault(), out assignment1))
{
SimpleAssignmentStatement assignment2;
if (SimpleAssignmentStatement.TryCreate(elseClause.GetSingleStatementOrDefault(), out assignment2) &&
assignment1.Left.IsKind(SyntaxKind.IdentifierName) &&
assignment2.Left.IsKind(SyntaxKind.IdentifierName))
{
string identifier1 = ((IdentifierNameSyntax)assignment1.Left).Identifier.ValueText;
string identifier2 = ((IdentifierNameSyntax)assignment2.Left).Identifier.ValueText;
if (string.Equals(identifier1, identifier2, StringComparison.Ordinal) &&
string.Equals(identifier1, declarator.Identifier.ValueText, StringComparison.Ordinal) &&
options.CheckSpanDirectives(ifStatement.Parent, TextSpan.FromBounds(localDeclarationStatement.SpanStart, ifStatement.Span.End)))
{
return(new LocalDeclarationAndIfElseAssignmentWithConditionalExpression(localDeclarationStatement, ifStatement, assignment1.Right, assignment2.Right).ToImmutableArray());
}
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public static Task <Document> InlineLazyInitializationAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken)
{
StatementContainer container = StatementContainer.Create(ifStatement);
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(ifStatement);
StatementSyntax expressionStatement = (ExpressionStatementSyntax)statements[index + 1];
MemberInvocationStatement invocation = MemberInvocationStatement.Create((ExpressionStatementSyntax)expressionStatement);
ExpressionSyntax expression = invocation.Expression;
SimpleAssignmentStatement assignment = SimpleAssignmentStatement.Create((ExpressionStatementSyntax)ifStatement.GetSingleStatementOrDefault());
BinaryExpressionSyntax coalesceExpression = CSharpFactory.CoalesceExpression(expression.WithoutTrivia(), ParenthesizedExpression(assignment.AssignmentExpression));
ParenthesizedExpressionSyntax newExpression = ParenthesizedExpression(coalesceExpression)
.WithTriviaFrom(expression);
StatementSyntax newExpressionStatement = expressionStatement.ReplaceNode(expression, newExpression);
IEnumerable <SyntaxTrivia> trivia = container.Node.DescendantTrivia(TextSpan.FromBounds(ifStatement.FullSpan.Start, expressionStatement.FullSpan.Start));
if (trivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia()))
{
newExpressionStatement = newExpressionStatement.PrependToLeadingTrivia(trivia);
}
SyntaxList <StatementSyntax> newStatements = statements
.Replace(expressionStatement, newExpressionStatement)
.RemoveAt(index);
return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken));
}
private static bool CanRefactor(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement, ReturnStatementSyntax returnStatement)
{
SimpleIfStatementWithSingleStatement simpleIf;
if (SimpleIfStatementWithSingleStatement.TryCreate(ifStatement, out simpleIf))
{
EqualsToNullExpression equalsToNull;
if (EqualsToNullExpression.TryCreate(simpleIf.Condition, out equalsToNull))
{
IdentifierNameSyntax identifierName = GetIdentifierName(equalsToNull.Left);
if (identifierName != null)
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
var fieldSymbol = semanticModel.GetSymbol(identifierName, cancellationToken) as IFieldSymbol;
if (fieldSymbol != null)
{
SimpleAssignmentStatement assignment;
if (SimpleAssignmentStatement.TryCreate(simpleIf.SingleStatement, out assignment))
{
string fieldName = identifierName.Identifier.ValueText;
return(assignment.Right.IsSingleLine() &&
IsBackingField(GetIdentifierName(assignment.Left), fieldName, fieldSymbol, semanticModel, cancellationToken) &&
IsBackingField(GetIdentifierName(returnStatement.Expression), fieldName, fieldSymbol, semanticModel, cancellationToken));
}
}
}
}
}
return(false);
}
