private static bool IsElseIfOrElseClauseEquivalent( ISyntaxFactsService syntaxFacts, IBlockFactsService blockFacts, IIfLikeStatementGenerator ifGenerator, SyntaxNode elseIfOrElseClause1, SyntaxNode elseIfOrElseClause2) { // Compare Else/ElseIf clauses for equality. var isIfStatement = ifGenerator.IsIfOrElseIf(elseIfOrElseClause1); if (isIfStatement != ifGenerator.IsIfOrElseIf(elseIfOrElseClause2)) { // If we have one Else and one ElseIf, they're not equal. return(false); } if (isIfStatement) { // If we have two ElseIf blocks, their conditions have to match. var condition1 = ifGenerator.GetCondition(elseIfOrElseClause1); var condition2 = ifGenerator.GetCondition(elseIfOrElseClause2); if (!syntaxFacts.AreEquivalent(condition1, condition2)) { return(false); } } var statements1 = WalkDownScopeBlocks(blockFacts, blockFacts.GetStatementContainerStatements(elseIfOrElseClause1)); var statements2 = WalkDownScopeBlocks(blockFacts, blockFacts.GetStatementContainerStatements(elseIfOrElseClause2)); return(statements1.SequenceEqual(statements2, syntaxFacts.AreEquivalent)); }
private static bool ContainEquivalentStatements( ISyntaxFactsService syntaxFacts, IBlockFactsService blockFacts, SyntaxNode ifStatement1, SyntaxNode ifStatement2, out IReadOnlyList <SyntaxNode> statements) { var statements1 = WalkDownScopeBlocks(blockFacts, blockFacts.GetStatementContainerStatements(ifStatement1)); var statements2 = WalkDownScopeBlocks(blockFacts, blockFacts.GetStatementContainerStatements(ifStatement2)); statements = statements1; return(statements1.SequenceEqual(statements2, syntaxFacts.AreEquivalent)); }
private static bool IsFirstStatementOfIfOrElseIf( IBlockFactsService blockFacts, IIfLikeStatementGenerator ifGenerator, SyntaxNode statement, out SyntaxNode ifOrElseIf) { // Check whether the statement is a first statement inside an if or else if. // If it's inside a block, it has to be the first statement of the block. // We can't assume that a statement will always be in a statement container, because an if statement // in top level code will be in a GlobalStatement. if (blockFacts.IsStatementContainer(statement.Parent)) { var statements = blockFacts.GetStatementContainerStatements(statement.Parent); if (statements.Count > 0 && statements[0] == statement) { var rootStatements = WalkUpScopeBlocks(blockFacts, statements); if (rootStatements.Count > 0 && ifGenerator.IsIfOrElseIf(rootStatements[0].Parent)) { ifOrElseIf = rootStatements[0].Parent; return(true); } } } ifOrElseIf = null; return(false); }
private static bool IsFirstStatementIfStatement( IBlockFactsService blockFacts, IIfLikeStatementGenerator ifGenerator, SyntaxNode ifOrElseIf, out SyntaxNode ifStatement) { // Check whether the first statement inside an if or else if is an if statement. // If the if statement is inside a block, it has to be the first statement of the block. // An if or else if should always be a statement container, but we'll do a defensive check anyway. Debug.Assert(blockFacts.IsStatementContainer(ifOrElseIf)); if (blockFacts.IsStatementContainer(ifOrElseIf)) { var rootStatements = blockFacts.GetStatementContainerStatements(ifOrElseIf); var statements = WalkDownScopeBlocks(blockFacts, rootStatements); if (statements.Count > 0 && ifGenerator.IsIfOrElseIf(statements[0])) { ifStatement = statements[0]; return(true); } } ifStatement = null; return(false); }
private static async Task <bool> CanBeSeparateStatementsAsync( Document document, IBlockFactsService blockFacts, IIfLikeStatementGenerator ifGenerator, SyntaxNode ifOrElseIf, CancellationToken cancellationToken) { // In order to make separate statements, ifOrElseIf must be an if statement, not an else-if clause. if (ifGenerator.IsElseIfClause(ifOrElseIf, out _)) { return(false); } // If there is an else clause, we *could* in theory separate these and move the current else clause to the second // statement, but we won't. It would break the else-if chain in an odd way. We'll insert an else-if instead. if (ifGenerator.GetElseIfAndElseClauses(ifOrElseIf).Length > 0) { return(false); } var insideStatements = blockFacts.GetStatementContainerStatements(ifOrElseIf); if (insideStatements.Count == 0) { // Even though there are no statements inside, we still can't split this into separate statements // because it would change the semantics from short-circuiting to always evaluating the second condition, // breaking code like 'if (a == null || a.InstanceMethod())'. return(false); } else { // There are statements inside. We can split this into separate statements and leave out the 'else' if // control flow can't reach the end of these statements (otherwise, it would continue to the second 'if' // and in the case that both conditions are true, run the same statements twice). // This will typically look like a single return, break, continue or a throw statement. var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var controlFlow = semanticModel.AnalyzeControlFlow(insideStatements[0], insideStatements[insideStatements.Count - 1]); return(!controlFlow.EndPointIsReachable); } }
private static async Task <bool> CanBeMergedAsync( Document document, ISyntaxFactsService syntaxFacts, IBlockFactsService blockFacts, IIfLikeStatementGenerator ifGenerator, SyntaxNode outerIfOrElseIf, SyntaxNode innerIfStatement, CancellationToken cancellationToken) { // We can only merge this with the outer if statement if any inner else-if and else clauses are equal // to else-if and else clauses following the outer if statement because we'll be removing the inner ones. // Example of what we can merge: // if (a) // { // if (b) // Console.WriteLine(); // else // Foo(); // } // else // { // Foo(); // } if (!System.Linq.ImmutableArrayExtensions.SequenceEqual( ifGenerator.GetElseIfAndElseClauses(outerIfOrElseIf), ifGenerator.GetElseIfAndElseClauses(innerIfStatement), (a, b) => IsElseIfOrElseClauseEquivalent(syntaxFacts, blockFacts, ifGenerator, a, b))) { return(false); } var statements = blockFacts.GetStatementContainerStatements(innerIfStatement.Parent); if (statements.Count == 1) { // There are no other statements below the inner if statement. Merging is OK. return(true); } else { // There are statements below the inner if statement. We can merge if // 1. there are equivalent statements below the outer 'if', and // 2. control flow can't reach the end of these statements (otherwise, it would continue // below the outer 'if' and run the same statements twice). // This will typically look like a single return, break, continue or a throw statement. // The opposite refactoring (SplitIntoNestedIfStatements) never generates this but we support it anyway. // Example: // if (a) // { // if (b) // Console.WriteLine(); // return; // } // return; // If we have an else-if, get the topmost if statement. var outerIfStatement = ifGenerator.GetRootIfStatement(outerIfOrElseIf); // A statement should always be in a statement container, but we'll do a defensive check anyway so that // we don't crash if the helper is missing some cases or there's a new language feature it didn't account for. Debug.Assert(blockFacts.GetStatementContainer(outerIfStatement) is object); if (blockFacts.GetStatementContainer(outerIfStatement) is not { } container) { return(false); } var outerStatements = blockFacts.GetStatementContainerStatements(container); var outerIfStatementIndex = outerStatements.IndexOf(outerIfStatement); var remainingStatements = statements.Skip(1); var remainingOuterStatements = outerStatements.Skip(outerIfStatementIndex + 1); if (!remainingStatements.SequenceEqual(remainingOuterStatements.Take(statements.Count - 1), syntaxFacts.AreEquivalent)) { return(false); } var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); var controlFlow = semanticModel.AnalyzeControlFlow(statements[0], statements[statements.Count - 1]); return(!controlFlow.EndPointIsReachable); } }