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)); }