internal static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement)
{
SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement);
if (!simpleIf.Success)
{
return;
}
if (simpleIf.Condition.Kind() != SyntaxKind.LogicalOrExpression)
{
return;
}
context.RegisterRefactoring(
"Split if",
cancellationToken => RefactorAsync(context.Document, ifStatement, cancellationToken));
}
public static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
if (ifStatement.SpanContainsDirectives())
{
return;
}
SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement);
if (!simpleIf.Success)
{
return;
}
if (simpleIf.Condition.Kind() == SyntaxKind.LogicalOrExpression)
{
return;
}
SimpleIfStatementInfo nestedIf = SyntaxInfo.SimpleIfStatementInfo(GetNestedIfStatement(ifStatement));
if (!nestedIf.Success)
{
return;
}
if (nestedIf.Condition.Kind() == SyntaxKind.LogicalOrExpression)
{
return;
}
if (!CheckTrivia(ifStatement, nestedIf.IfStatement))
{
return;
}
ReportDiagnostic(context, ifStatement, nestedIf.IfStatement);
}
internal static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement)
{
SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement);
if (simpleIf.Success)
{
if (simpleIf.Condition.IsKind(SyntaxKind.LogicalOrExpression))
{
context.RegisterRefactoring(
"Split if",
ct => SplitSimpleIfAsync(context.Document, ifStatement, ct),
RefactoringDescriptors.SplitIf);
}
}
else if (ifStatement.IsParentKind(SyntaxKind.ElseClause) &&
ifStatement.Else == null &&
ifStatement.Condition.IsKind(SyntaxKind.LogicalOrExpression))
{
context.RegisterRefactoring(
"Split if",
ct => SplitLastElseIfAsync(context.Document, ifStatement, ct),
RefactoringDescriptors.SplitIf);
}
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode node, BlockSyntax body)
{
if (body == null)
{
return;
}
if (body.ContainsDiagnostics)
{
return;
}
SyntaxList <StatementSyntax> statements = body.Statements;
if (statements.Count != 2)
{
return;
}
if (!(statements[0] is IfStatementSyntax ifStatement))
{
return;
}
if (!(statements[1] is ReturnStatementSyntax returnStatement))
{
return;
}
ExpressionSyntax returnExpression = returnStatement.Expression;
if (returnExpression?.IsKind(SyntaxKind.IdentifierName, SyntaxKind.SimpleMemberAccessExpression) != true)
{
return;
}
if (ifStatement.SpanOrTrailingTriviaContainsDirectives())
{
return;
}
if (returnStatement.SpanOrLeadingTriviaContainsDirectives())
{
return;
}
SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement);
if (!simpleIf.Success)
{
return;
}
StatementSyntax statement = simpleIf.IfStatement.SingleNonBlockStatementOrDefault();
if (statement == null)
{
return;
}
SimpleAssignmentStatementInfo assignmentInfo = SyntaxInfo.SimpleAssignmentStatementInfo(statement);
if (!assignmentInfo.Success)
{
return;
}
if (!assignmentInfo.Left.IsKind(SyntaxKind.IdentifierName, SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(simpleIf.Condition, semanticModel: semanticModel, allowedStyles: NullCheckStyles.CheckingNull, cancellationToken: cancellationToken);
if (!nullCheck.Success)
{
return;
}
ExpressionSyntax expression = nullCheck.Expression;
if (!expression.IsKind(SyntaxKind.IdentifierName, SyntaxKind.SimpleMemberAccessExpression))
{
return;
}
if (!(semanticModel.GetSymbol(expression, cancellationToken) is IFieldSymbol fieldSymbol))
{
return;
}
if (!ExpressionEquals(expression, assignmentInfo.Left))
{
return;
}
if (fieldSymbol.Type.IsNullableType() &&
returnExpression.Kind() == SyntaxKind.SimpleMemberAccessExpression)
{
var memberAccessExpression = (MemberAccessExpressionSyntax)returnExpression;
if (memberAccessExpression.Name is IdentifierNameSyntax identifierName &&
string.Equals(identifierName.Identifier.ValueText, "Value", StringComparison.Ordinal))
{
returnExpression = memberAccessExpression.Expression;
}
}
if (!ExpressionEquals(expression, returnExpression))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context,
DiagnosticDescriptors.SimplifyLazyInitialization,
Location.Create(node.SyntaxTree, TextSpan.FromBounds(ifStatement.SpanStart, returnStatement.Span.End)));
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode node, BlockSyntax body)
{
if (body == null)
{
return;
}
if (body.ContainsDiagnostics)
{
return;
}
SyntaxList <StatementSyntax> statements = body.Statements;
if (statements.Count != 2)
{
return;
}
if (!(statements[0] is IfStatementSyntax ifStatement))
{
return;
}
if (!(statements[1] is ReturnStatementSyntax returnStatement))
{
return;
}
TextSpan span = TextSpan.FromBounds(ifStatement.SpanStart, returnStatement.Span.End);
if (body.ContainsDirectives(span))
{
return;
}
SimpleIfStatementInfo simpleIf = SyntaxInfo.SimpleIfStatementInfo(ifStatement);
if (!simpleIf.Success)
{
return;
}
StatementSyntax statement = simpleIf.Statement.SingleNonBlockStatementOrDefault();
if (statement == null)
{
return;
}
SemanticModel semanticModel = context.SemanticModel;
CancellationToken cancellationToken = context.CancellationToken;
NullCheckExpressionInfo nullCheck = SyntaxInfo.NullCheckExpressionInfo(simpleIf.Condition, allowedKinds: NullCheckKind.IsNull, semanticModel: semanticModel, cancellationToken: cancellationToken);
if (!nullCheck.Success)
{
return;
}
IdentifierNameSyntax identifierName = GetIdentifierName(nullCheck.Expression);
if (identifierName == null)
{
return;
}
if (!(semanticModel.GetSymbol(identifierName, cancellationToken) is IFieldSymbol fieldSymbol))
{
return;
}
SimpleAssignmentStatementInfo assignmentInfo = SyntaxInfo.SimpleAssignmentStatementInfo(statement);
if (!assignmentInfo.Success)
{
return;
}
string name = identifierName.Identifier.ValueText;
IdentifierNameSyntax identifierName2 = GetIdentifierName(assignmentInfo.Left);
if (!IsBackingField(identifierName2, name, fieldSymbol, semanticModel, cancellationToken))
{
return;
}
IdentifierNameSyntax identifierName3 = GetIdentifierName(returnStatement.Expression, semanticModel, cancellationToken);
if (!IsBackingField(identifierName3, name, fieldSymbol, semanticModel, cancellationToken))
{
return;
}
context.ReportDiagnostic(
DiagnosticDescriptors.SimplifyLazyInitialization,
Location.Create(node.SyntaxTree, span));
}