private static void Analyze(
SyntaxNodeAnalysisContext context,
SyntaxList <StatementSyntax> statements,
SingleLocalDeclarationStatement localDeclaration,
ExpressionSyntax expression)
{
if (expression?.IsKind(SyntaxKind.IdentifierName) == true)
{
var identifierName = (IdentifierNameSyntax)expression;
string name = localDeclaration.IdentifierText;
if (string.Equals(name, identifierName.Identifier.ValueText, StringComparison.Ordinal))
{
TextSpan span = TextSpan.FromBounds(expression.Span.End, statements.Last().Span.End);
SyntaxNode parent = localDeclaration.Statement.Parent;
if (!IsLocalVariableReferenced(localDeclaration.Declarator, name, parent, span, context.SemanticModel, context.CancellationToken) &&
!parent.ContainsDirectives(TextSpan.FromBounds(localDeclaration.Statement.SpanStart, expression.Span.End)))
{
ReportDiagnostic(context, localDeclaration, expression);
}
}
}
}
private static bool CanRefactor(
ExpressionStatementSyntax expressionStatement,
IfStatementSyntax ifStatement,
ExpressionSyntax expression,
SyntaxNode parent)
{
ExpressionSyntax expression2 = expressionStatement.Expression;
if (expression2?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
var assignment = (AssignmentExpressionSyntax)expression2;
ExpressionSyntax left = assignment.Left;
if (left?.IsMissing == false)
{
ExpressionSyntax right = assignment.Right;
return(right?.IsMissing == false &&
SyntaxComparer.AreEquivalent(expression, left) &&
!parent.ContainsDirectives(TextSpan.FromBounds(right.Span.End, ifStatement.Span.Start)));
}
}
return(false);
}
private static bool CanRefactor(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
ExpressionSyntax expression,
SyntaxNode parent)
{
VariableDeclarationSyntax declaration = localDeclarationStatement.Declaration;
if (declaration != null)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
if (variables.Count == 1)
{
VariableDeclaratorSyntax declarator = variables[0];
ExpressionSyntax value = declarator.Initializer?.Value;
return(value != null &&
expression.IsKind(SyntaxKind.IdentifierName) &&
string.Equals(declarator.Identifier.ValueText, ((IdentifierNameSyntax)expression).Identifier.ValueText, StringComparison.Ordinal) &&
!parent.ContainsDirectives(TextSpan.FromBounds(value.Span.End, ifStatement.Span.Start)));
}
}
return(false);
}
public static bool SpanContainsDirectives(this SyntaxNode node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
return(node.ContainsDirectives(node.Span));
}
public static bool CheckSpanDirectives(this AnalysisOptions options, SyntaxNode node, TextSpan span)
{
if (!options.CanContainDirectives)
{
if (node.Span.Contains(span))
{
return(!node.ContainsDirectives(span));
}
foreach (SyntaxNode ancestor in node.Ancestors())
{
if (ancestor.Span.Contains(span))
{
return(!ancestor.ContainsDirectives(span));
}
}
}
return(true);
}
private static bool IsFixable(
LocalDeclarationStatementSyntax localDeclarationStatement,
IfStatementSyntax ifStatement,
ExpressionSyntax expression,
SyntaxNode parent)
{
VariableDeclaratorSyntax declarator = localDeclarationStatement
.Declaration?
.Variables
.SingleOrDefault(shouldThrow: false);
if (declarator != null)
{
ExpressionSyntax value = declarator.Initializer?.Value;
return(value != null &&
expression.IsKind(SyntaxKind.IdentifierName) &&
string.Equals(declarator.Identifier.ValueText, ((IdentifierNameSyntax)expression).Identifier.ValueText, StringComparison.Ordinal) &&
!parent.ContainsDirectives(TextSpan.FromBounds(value.Span.End, ifStatement.SpanStart)));
}
return(false);
}
private static void Analyze(
SyntaxNodeAnalysisContext context,
SyntaxNode containingNode,
SyntaxList <StatementSyntax> statements)
{
int count = statements.Count;
if (count > 1)
{
int i = count - 1;
while (i >= 0)
{
if (!statements[i].IsKind(SyntaxKind.LocalFunctionStatement))
{
break;
}
i--;
}
if (i >= 1 &&
statements[i].IsKind(SyntaxKind.ReturnStatement))
{
var returnStatement = (ReturnStatementSyntax)statements[i];
ExpressionSyntax expression = returnStatement.Expression;
if (expression?.IsMissing == false)
{
StatementSyntax statement = statements[i - 1];
SyntaxKind statementKind = statement.Kind();
if (statementKind == SyntaxKind.IfStatement)
{
var ifStatement = (IfStatementSyntax)statements[i - 1];
if (!ifStatement.IsSimpleIf())
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
ISymbol symbol = semanticModel.GetSymbol(expression, cancellationToken);
if (IsLocalDeclaredInScopeOrNonRefOrOutParameterOfEnclosingSymbol(symbol, containingNode, semanticModel, cancellationToken) &&
ifStatement.GetChain().All(ifOrElse => IsValueAssignedInLastStatement(ifOrElse, symbol, semanticModel, cancellationToken)) &&
!containingNode.ContainsDirectives(TextSpan.FromBounds(ifStatement.SpanStart, returnStatement.Span.End)))
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseReturnInsteadOfAssignment,
GetLastStatementOrDefault(ifStatement));
}
}
}
else if (statementKind == SyntaxKind.SwitchStatement)
{
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
ISymbol symbol = semanticModel.GetSymbol(expression, cancellationToken);
if (IsLocalDeclaredInScopeOrNonRefOrOutParameterOfEnclosingSymbol(symbol, containingNode, semanticModel, cancellationToken))
{
var switchStatement = (SwitchStatementSyntax)statements[i - 1];
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
if (sections.All(section => IsValueAssignedInLastStatement(section, symbol, semanticModel, cancellationToken)) &&
!containingNode.ContainsDirectives(TextSpan.FromBounds(switchStatement.SpanStart, returnStatement.Span.End)))
{
context.ReportDiagnostic(
DiagnosticDescriptors.UseReturnInsteadOfAssignment,
GetLastStatementBeforeBreakStatementOrDefault(sections.First()));
}
}
}
}
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, LocalDeclarationStatementSyntax localDeclaration)
{
VariableDeclarationSyntax declaration = localDeclaration.Declaration;
if (declaration != null)
{
SeparatedSyntaxList <VariableDeclaratorSyntax> variables = declaration.Variables;
if (variables.Count == 1)
{
VariableDeclaratorSyntax declarator = variables[0];
EqualsValueClauseSyntax initializer = declarator.Initializer;
if (initializer != null)
{
ExpressionSyntax value = initializer.Value;
if (value != null)
{
SyntaxToken identifier = declarator.Identifier;
SyntaxNode parent = localDeclaration.Parent;
SyntaxList <StatementSyntax> statements = GetStatements(parent);
if (statements.Any())
{
int index = statements.IndexOf(localDeclaration);
if (index < statements.Count - 1)
{
StatementSyntax nextStatement = statements[index + 1];
ExpressionSyntax right = GetAssignedValue(nextStatement);
if (right?.IsKind(SyntaxKind.IdentifierName) == true)
{
var identifierName = (IdentifierNameSyntax)right;
if (identifier.ValueText == identifierName.Identifier.ValueText)
{
bool isReferenced = false;
if (index < statements.Count - 2)
{
TextSpan span = TextSpan.FromBounds(statements[index + 2].SpanStart, statements.Last().Span.End);
isReferenced = IsLocalVariableReferenced(context, parent, span, declarator, identifier);
}
if (!isReferenced &&
!parent.ContainsDirectives(TextSpan.FromBounds(localDeclaration.SpanStart, nextStatement.Span.End)))
{
ReportDiagnostic(context, localDeclaration, declaration, identifier, initializer, right);
}
}
}
else if (nextStatement.IsKind(SyntaxKind.ForEachStatement))
{
var forEachStatement = (ForEachStatementSyntax)nextStatement;
ExpressionSyntax expression = forEachStatement.Expression;
if (expression?.IsKind(SyntaxKind.IdentifierName) == true)
{
var identifierName = (IdentifierNameSyntax)expression;
if (identifier.ValueText == identifierName.Identifier.ValueText)
{
TextSpan span = TextSpan.FromBounds(expression.Span.End, statements.Last().Span.End);
if (!IsLocalVariableReferenced(context, parent, span, declarator, identifier) &&
!parent.ContainsDirectives(TextSpan.FromBounds(localDeclaration.SpanStart, expression.Span.End)))
{
ReportDiagnostic(context, localDeclaration, declaration, identifier, initializer, expression);
}
}
}
}
}
}
}
}
}
}
}
