コード例 #1
0
            private void AddPrecedingRelevantExpressions()
            {
                // If we're not the first statement in this block, 
                // and there's an expression or declaration statement directly above us,
                // then add the expressions from that as well.

                StatementSyntax previousStatement;

                var block = _parentStatement as BlockSyntax;
                if (block != null &&
                    block.CloseBraceToken == _token)
                {
                    // If we're at the last brace of a block, use the last
                    // statement in the block.
                    previousStatement = block.Statements.LastOrDefault();
                }
                else
                {
                    previousStatement = _parentStatement.GetPreviousStatement();
                }

                if (previousStatement != null)
                {
                    switch (previousStatement.Kind())
                    {
                        case SyntaxKind.ExpressionStatement:
                        case SyntaxKind.LocalDeclarationStatement:
                            AddRelevantExpressions(previousStatement, _expressions, includeDeclarations: true);
                            break;
                        case SyntaxKind.DoStatement:
                            AddExpressionTerms((previousStatement as DoStatementSyntax).Condition, _expressions);
                            AddLastStatementOfConstruct(previousStatement);
                            break;
                        case SyntaxKind.ForStatement:
                        case SyntaxKind.ForEachStatement:
                        case SyntaxKind.IfStatement:
                        case SyntaxKind.CheckedStatement:
                        case SyntaxKind.UncheckedStatement:
                        case SyntaxKind.WhileStatement:
                        case SyntaxKind.LockStatement:
                        case SyntaxKind.SwitchStatement:
                        case SyntaxKind.TryStatement:
                        case SyntaxKind.UsingStatement:
                            AddRelevantExpressions(previousStatement, _expressions, includeDeclarations: false);
                            AddLastStatementOfConstruct(previousStatement);
                            break;
                        default:
                            break;
                    }
                }
                else
                {
                    // This is the first statement of the block. Go to the nearest enclosing statement and add its expressions
                    var statementAncestor = _parentStatement.Ancestors().OfType<StatementSyntax>().FirstOrDefault(node => !node.IsKind(SyntaxKind.Block));
                    if (statementAncestor != null)
                    {
                        AddRelevantExpressions(statementAncestor, _expressions, includeDeclarations: true);
                    }
                }
            }
コード例 #2
0
            private void AddLastStatementOfConstruct(StatementSyntax statement)
            {
                if (statement == default(StatementSyntax))
                {
                    return;
                }

                switch (statement.Kind())
                {
                    case SyntaxKind.Block:
                        AddLastStatementOfConstruct((statement as BlockSyntax).Statements.LastOrDefault());
                        break;
                    case SyntaxKind.BreakStatement:
                    case SyntaxKind.ContinueStatement:
                        AddLastStatementOfConstruct(statement.GetPreviousStatement());
                        break;
                    case SyntaxKind.CheckedStatement:
                    case SyntaxKind.UncheckedStatement:
                        AddLastStatementOfConstruct((statement as CheckedStatementSyntax).Block);
                        break;
                    case SyntaxKind.DoStatement:
                        AddLastStatementOfConstruct((statement as DoStatementSyntax).Statement);
                        break;
                    case SyntaxKind.ForStatement:
                        AddLastStatementOfConstruct((statement as ForStatementSyntax).Statement);
                        break;
                    case SyntaxKind.ForEachStatement:
                    case SyntaxKind.ForEachVariableStatement:
                        AddLastStatementOfConstruct((statement as CommonForEachStatementSyntax).Statement);
                        break;
                    case SyntaxKind.IfStatement:
                        var ifStatement = statement as IfStatementSyntax;
                        AddLastStatementOfConstruct(ifStatement.Statement);
                        if (ifStatement.Else != null)
                        {
                            AddLastStatementOfConstruct(ifStatement.Else.Statement);
                        }

                        break;
                    case SyntaxKind.LockStatement:
                        AddLastStatementOfConstruct((statement as LockStatementSyntax).Statement);
                        break;
                    case SyntaxKind.SwitchStatement:
                        var switchStatement = statement as SwitchStatementSyntax;
                        foreach (var section in switchStatement.Sections)
                        {
                            AddLastStatementOfConstruct(section.Statements.LastOrDefault());
                        }

                        break;
                    case SyntaxKind.TryStatement:
                        var tryStatement = statement as TryStatementSyntax;
                        if (tryStatement.Finally != null)
                        {
                            AddLastStatementOfConstruct(tryStatement.Finally.Block);
                        }
                        else
                        {
                            AddLastStatementOfConstruct(tryStatement.Block);
                            foreach (var catchClause in tryStatement.Catches)
                            {
                                AddLastStatementOfConstruct(catchClause.Block);
                            }
                        }

                        break;
                    case SyntaxKind.UsingStatement:
                        AddLastStatementOfConstruct((statement as UsingStatementSyntax).Statement);
                        break;
                    case SyntaxKind.WhileStatement:
                        AddLastStatementOfConstruct((statement as WhileStatementSyntax).Statement);
                        break;
                    default:
                        AddRelevantExpressions(statement, _expressions, includeDeclarations: false);
                        break;
                }
            }
コード例 #3
0
            private void AddLastStatementOfConstruct(StatementSyntax statement)
            {
                if (statement == default(StatementSyntax))
                {
                    return;
                }

                switch (statement.Kind())
                {
                case SyntaxKind.Block:
                    AddLastStatementOfConstruct((statement as BlockSyntax).Statements.LastOrDefault());
                    break;

                case SyntaxKind.BreakStatement:
                case SyntaxKind.ContinueStatement:
                    AddLastStatementOfConstruct(statement.GetPreviousStatement());
                    break;

                case SyntaxKind.CheckedStatement:
                case SyntaxKind.UncheckedStatement:
                    AddLastStatementOfConstruct((statement as CheckedStatementSyntax).Block);
                    break;

                case SyntaxKind.DoStatement:
                    AddLastStatementOfConstruct((statement as DoStatementSyntax).Statement);
                    break;

                case SyntaxKind.ForStatement:
                    AddLastStatementOfConstruct((statement as ForStatementSyntax).Statement);
                    break;

                case SyntaxKind.ForEachStatement:
                case SyntaxKind.ForEachComponentStatement:
                    AddLastStatementOfConstruct((statement as CommonForEachStatementSyntax).Statement);
                    break;

                case SyntaxKind.IfStatement:
                    var ifStatement = statement as IfStatementSyntax;
                    AddLastStatementOfConstruct(ifStatement.Statement);
                    if (ifStatement.Else != null)
                    {
                        AddLastStatementOfConstruct(ifStatement.Else.Statement);
                    }

                    break;

                case SyntaxKind.LockStatement:
                    AddLastStatementOfConstruct((statement as LockStatementSyntax).Statement);
                    break;

                case SyntaxKind.SwitchStatement:
                    var switchStatement = statement as SwitchStatementSyntax;
                    foreach (var section in switchStatement.Sections)
                    {
                        AddLastStatementOfConstruct(section.Statements.LastOrDefault());
                    }

                    break;

                case SyntaxKind.TryStatement:
                    var tryStatement = statement as TryStatementSyntax;
                    if (tryStatement.Finally != null)
                    {
                        AddLastStatementOfConstruct(tryStatement.Finally.Block);
                    }
                    else
                    {
                        AddLastStatementOfConstruct(tryStatement.Block);
                        foreach (var catchClause in tryStatement.Catches)
                        {
                            AddLastStatementOfConstruct(catchClause.Block);
                        }
                    }

                    break;

                case SyntaxKind.UsingStatement:
                    AddLastStatementOfConstruct((statement as UsingStatementSyntax).Statement);
                    break;

                case SyntaxKind.WhileStatement:
                    AddLastStatementOfConstruct((statement as WhileStatementSyntax).Statement);
                    break;

                default:
                    AddRelevantExpressions(statement, _expressions, includeDeclarations: false);
                    break;
                }
            }