private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context, SyntaxToken token, StatementSyntax statement)
{
if (statement != null &&
EmbeddedStatement.IsEmbeddedStatement(statement))
{
Analyze(context, token, statement);
}
}
public static async Task <Document> RefactorAsync(
Document document,
ReturnStatementSyntax returnStatement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxToken returnKeyword = returnStatement.ReturnKeyword;
ExpressionSyntax expression = returnStatement.Expression;
switch (GetReplacementKind(returnStatement, null, semanticModel, cancellationToken))
{
case SyntaxKind.YieldReturnStatement:
{
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(returnKeyword.LeadingTrivia, SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
expression,
returnStatement.SemicolonToken);
return(await document.ReplaceNodeAsync(returnStatement, yieldReturnStatement, cancellationToken).ConfigureAwait(false));
}
case SyntaxKind.ForEachStatement:
{
string identifier = Identifier.EnsureUniqueLocalName("item", returnStatement.SpanStart, semanticModel, cancellationToken);
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(default(SyntaxTriviaList), SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
IdentifierName(identifier),
returnStatement.SemicolonToken.WithoutTrailingTrivia());
StatementSyntax newNode = ForEachStatement(
VarType(),
identifier,
expression,
Block(yieldReturnStatement));
if (EmbeddedStatement.IsEmbeddedStatement(returnStatement))
{
newNode = Block(newNode);
}
newNode = newNode.WithTriviaFrom(returnStatement);
return(await document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken).ConfigureAwait(false));
}
default:
{
Debug.Assert(false, "");
return(document);
}
}
}
private static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
StatementSyntax statement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (EmbeddedStatement.IsEmbeddedStatement(statement))
{
return(await document.ReplaceNodeAsync(statement, Block(statement, CreateNullCheck(expression)), cancellationToken).ConfigureAwait(false));
}
else
{
StatementContainer container;
if (StatementContainer.TryCreate(statement, out container))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int statementIndex = statements.IndexOf(statement);
ISymbol symbol = (statement.IsKind(SyntaxKind.LocalDeclarationStatement))
? semanticModel.GetDeclaredSymbol(((LocalDeclarationStatementSyntax)statement).Declaration.Variables.First(), cancellationToken)
: semanticModel.GetSymbol(expression, cancellationToken);
int lastStatementIndex = IncludeAllReferencesOfSymbol(symbol, expression.Kind(), statements, statementIndex + 1, semanticModel, cancellationToken);
if (lastStatementIndex != -1)
{
if (lastStatementIndex < statements.Count - 1)
{
lastStatementIndex = IncludeAllReferencesOfVariablesDeclared(statements, statementIndex + 1, lastStatementIndex, semanticModel, cancellationToken);
}
return(await RefactorAsync(
document,
expression,
statements,
container,
statementIndex,
lastStatementIndex,
cancellationToken).ConfigureAwait(false));
}
}
}
return(await document.InsertNodeAfterAsync(statement, CreateNullCheck(expression), cancellationToken).ConfigureAwait(false));
}
private static bool NullCheckExists(ExpressionSyntax expression, StatementSyntax statement)
{
if (!EmbeddedStatement.IsEmbeddedStatement(statement))
{
StatementContainer container;
if (StatementContainer.TryCreate(statement, out container))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(statement);
if (index < statements.Count - 1)
{
StatementSyntax nextStatement = statements[index + 1];
if (nextStatement.IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)nextStatement;
ExpressionSyntax condition = ifStatement.Condition;
if (condition?.IsKind(SyntaxKind.NotEqualsExpression) == true)
{
var notEqualsExpression = (BinaryExpressionSyntax)condition;
ExpressionSyntax left = notEqualsExpression.Left;
if (left?.IsEquivalentTo(expression, topLevel: false) == true)
{
ExpressionSyntax right = notEqualsExpression.Right;
if (right?.IsKind(SyntaxKind.NullLiteralExpression) == true)
{
return(true);
}
}
}
}
}
}
}
return(false);
}
public static void ComputeRefactoring(RefactoringContext context, BlockSyntax block)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.RemoveStatement,
RefactoringIdentifiers.DuplicateStatement,
RefactoringIdentifiers.CommentOutStatement))
{
StatementSyntax statement = GetStatement(context, block, block.Parent);
if (statement != null)
{
if (!EmbeddedStatement.IsEmbeddedStatement(statement) &&
statement.IsParentKind(SyntaxKind.Block))
{
RegisterRefactoring(context, statement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutStatement))
{
CommentOutRefactoring.RegisterRefactoring(context, statement);
}
}
}
}
private static bool CanRefactor(RefactoringContext context, StatementSyntax statement)
{
return(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(statement) &&
EmbeddedStatement.IsEmbeddedStatement(statement));
}