public override void Execute(EditorContext context)
{
IProject project = (IProject)ClassAtCaret.Class.ProjectContent.Project;
RefactoringHelpers.RenameFile(project, ClassAtCaret.Class.CompilationUnit.FileName, ClassAtCaret.CorrectClassFileName);
if (project != null)
{
project.Save();
}
}
internal static IEnumerable <CodeAction> ScanIfElse(SemanticModel ctx, Document document, SyntaxNode root, IfStatementSyntax ifElseStatement, BinaryExpressionSyntax isExpression, out int foundCastCount)
{
foundCastCount = 0;
var innerCondition = ifElseStatement.Condition.SkipParens();
if (innerCondition != null && innerCondition.IsKind(SyntaxKind.LogicalNotExpression))
{
var c2 = ((PrefixUnaryExpressionSyntax)innerCondition).Operand.SkipParens();
if (c2.IsKind(SyntaxKind.IsExpression))
{
return(HandleNegatedCase(ctx, document, root, ifElseStatement, ifElseStatement.Condition, isExpression, out foundCastCount));
}
return(Enumerable.Empty <CodeAction>());
}
var castToType = isExpression.Right;
var embeddedStatment = ifElseStatement.Statement;
var rr = ctx.GetTypeInfo(castToType);
if (rr.Type == null || !rr.Type.IsReferenceType)
{
return(Enumerable.Empty <CodeAction>());
}
List <SyntaxNode> foundCasts;
foundCasts = embeddedStatment.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => IsCast(ctx, arg, rr.Type)).ToList();
foundCasts.AddRange(ifElseStatement.Condition.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => arg.SpanStart > isExpression.Span.End && IsCast(ctx, arg, rr.Type)));
foundCastCount = foundCasts.Count;
return(new[] {
CodeActionFactory.Create(
isExpression.Span,
DiagnosticSeverity.Info,
GettextCatalog.GetString("Use 'as' and check for null"),
t2 => {
var varName = NameGenerator.GenerateSafeCSharpName(
GetNameProposal(RefactoringHelpers.GuessNameFromType(rr.Type), ctx, isExpression));
var varDec = SyntaxFactory.LocalDeclarationStatement(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ParseTypeName("var"),
SyntaxFactory.SeparatedList(new [] {
SyntaxFactory.VariableDeclarator(varName)
.WithInitializer(SyntaxFactory.EqualsValueClause(
SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, isExpression.Left, isExpression.Right)
))
})
));
var outerIs = isExpression.AncestorsAndSelf().FirstOrDefault(e => !(e.Parent is ParenthesizedExpressionSyntax));
var binaryOperatorExpression = SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, SyntaxFactory.IdentifierName(varName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
SyntaxNode newRoot;
if (IsEmbeddedStatement(ifElseStatement))
{
foundCasts = ifElseStatement.DescendantNodesAndSelf(n => !IsCast(ctx, n, rr.Type)).Where(arg => IsCast(ctx, arg, rr.Type)).ToList();
var newIf = ifElseStatement.TrackNodes(foundCasts.Concat(new [] { outerIs }));
newIf = newIf.ReplaceNode((SyntaxNode)newIf.GetCurrentNode(outerIs), binaryOperatorExpression.WithAdditionalAnnotations(Formatter.Annotation));
foreach (var c in foundCasts)
{
newIf = newIf.ReplaceNode((SyntaxNode)newIf.GetCurrentNode(c), SyntaxFactory.IdentifierName(varName).WithAdditionalAnnotations(Formatter.Annotation));
}
var block = SyntaxFactory.Block(new StatementSyntax[] {
varDec,
newIf
});
newRoot = root.ReplaceNode((SyntaxNode)ifElseStatement, block.WithAdditionalAnnotations(Formatter.Annotation));
}
else
{
newRoot = root.TrackNodes(foundCasts.Concat(new SyntaxNode[] { ifElseStatement, outerIs }));
newRoot = newRoot.InsertNodesBefore(newRoot.GetCurrentNode(ifElseStatement), new [] { varDec.WithAdditionalAnnotations(Formatter.Annotation) });
newRoot = newRoot.ReplaceNode((SyntaxNode)newRoot.GetCurrentNode(outerIs), binaryOperatorExpression.WithAdditionalAnnotations(Formatter.Annotation));
foreach (var c in foundCasts)
{
newRoot = newRoot.ReplaceNode((SyntaxNode)newRoot.GetCurrentNode(c), SyntaxFactory.IdentifierName(varName).WithAdditionalAnnotations(Formatter.Annotation));
}
}
return Task.FromResult(document.WithSyntaxRoot(newRoot));
}
)
});
}
