static bool IsLastStatement(SyntaxList<StatementSyntax> statements, MultiLineIfBlockSyntax ifBlock)
 {
     return statements.IndexOf(ifBlock) + 1 >= statements.Count;
 }
 static IEnumerable<SyntaxNode> GetStatements(MultiLineIfBlockSyntax ifBlock)
 {
     foreach (var stmt in ifBlock.Statements)
         yield return stmt.WithAdditionalAnnotations(Formatter.Annotation);
 }
        static IEnumerable<SyntaxNode> GenerateNewScript(MultiLineIfBlockSyntax ifBlock)
        {
            var ifStatement = GenerateInvertedIfStatement(ifBlock.IfStatement);
            yield return SyntaxFactory.MultiLineIfBlock(ifStatement)
                .WithStatements(GenerateNewTrueStatement(ifBlock.ElseBlock.Statements))
                .WithLeadingTrivia(ifBlock.GetLeadingTrivia())
                .WithTrailingTrivia(ifBlock.GetTrailingTrivia())
                .WithAdditionalAnnotations(Formatter.Annotation);

            foreach (var stmt in ifBlock.Statements)
            {
                yield return stmt.WithAdditionalAnnotations(Formatter.Annotation);
            }
        }
        internal static bool CollectCaseBlocks(List<CaseBlockSyntax> result, SemanticModel context, MultiLineIfBlockSyntax ifBlock, ExpressionSyntax switchExpr)
        {
            // if
            var labels = new List<CaseClauseSyntax>();
            if (!CollectCaseLabels(labels, context, ifBlock.IfStatement.Condition, switchExpr))
                return false;

            result.Add(SyntaxFactory.CaseBlock(SyntaxFactory.CaseStatement(labels.ToArray()), ifBlock.Statements));

            foreach (var block in ifBlock.ElseIfBlocks)
            {
				labels = new List<CaseClauseSyntax>();
				if (!CollectCaseLabels(labels, context, block.ElseIfStatement.Condition, switchExpr))
					return false;

				result.Add(SyntaxFactory.CaseBlock(SyntaxFactory.CaseStatement(labels.ToArray()), block.Statements));
			}

			// else
			if (ifBlock.ElseBlock != null) {
				result.Add(SyntaxFactory.CaseElseBlock(SyntaxFactory.CaseElseStatement(SyntaxFactory.ElseCaseClause()), ifBlock.ElseBlock.Statements));
			}
			return true;
        }
예제 #5
0
        private Decisions TraverseMultiIfStatement(MultiLineIfBlockSyntax mlib, ref int returnCnt, bool nested = false)
        {
            Decisions retDecisions = new Decisions();

            foreach (SyntaxNode sn in mlib.ChildNodes())
            {
                if (sn is IfPartSyntax)
                {
                    retDecisions.IfStatements.Add(TraverseIfStatement(sn as IfPartSyntax, ref returnCnt, nested));
                }
                else if (sn is ElsePartSyntax)
                {
                    retDecisions.ElseStatements.Add(TraverseElseStatement(sn as ElsePartSyntax, ref returnCnt, nested));
                }
            }

            return retDecisions;
        }
예제 #6
0
 public override void VisitMultiLineIfBlock(MultiLineIfBlockSyntax node) =>
 counter.CheckNesting(node.IfStatement.IfKeyword, () => base.VisitMultiLineIfBlock(node));
예제 #7
0
        public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
        {
            var document = context.Document;

            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
            {
                return;
            }
            var span = context.Span;

            if (!span.IsEmpty)
            {
                return;
            }
            var cancellationToken = context.CancellationToken;

            if (cancellationToken.IsCancellationRequested)
            {
                return;
            }
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            if (model.IsFromGeneratedCode(cancellationToken))
            {
                return;
            }
            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

            var selectStatement = root.FindNode(span) as SelectStatementSyntax;

            if (selectStatement == null)
            {
                return;
            }
            var node = selectStatement.Parent as SelectBlockSyntax;

            if (node == null || node.CaseBlocks.Count == 0)
            {
                return;
            }

            if (node.CaseBlocks.Count == 1 && node.CaseBlocks[0].CaseStatement.Cases.OfType <ElseCaseClauseSyntax>().Any())
            {
                return;
            }

            foreach (var block in node.CaseBlocks)
            {
                var lastStatement = block.Statements.LastOrDefault() as ExitStatementSyntax;
                if (HasNonTrailingExitSelects(block, lastStatement != null && lastStatement.BlockKeyword.IsKind(SyntaxKind.SelectKeyword) ? lastStatement : null))
                {
                    return;
                }
            }

            context.RegisterRefactoring(
                CodeActionFactory.Create(
                    span,
                    DiagnosticSeverity.Info,
                    GettextCatalog.GetString("To 'if'"),
                    t2 =>
            {
                MultiLineIfBlockSyntax ifBlock   = null;
                List <ElseIfBlockSyntax> elseIfs = new List <ElseIfBlockSyntax>();
                ElseBlockSyntax defaultElse      = null;

                foreach (var block in node.CaseBlocks)
                {
                    var condition     = CollectCondition(node.SelectStatement.Expression, block.CaseStatement.Cases.ToArray());
                    var statements    = block.Statements;
                    var lastStatement = block.Statements.LastOrDefault() as ExitStatementSyntax;
                    if (lastStatement != null && lastStatement.BlockKeyword.IsKind(SyntaxKind.SelectKeyword))
                    {
                        statements = SyntaxFactory.List(statements.Take(statements.Count - 1));
                    }
                    if (condition == null)
                    {
                        defaultElse = SyntaxFactory.ElseBlock()
                                      .AddStatements(statements.ToArray())
                                      .WithLeadingTrivia(block.GetLeadingTrivia())
                                      .WithTrailingTrivia(block.GetTrailingTrivia());
                        break;
                    }
                    else if (ifBlock == null)
                    {
                        ifBlock = SyntaxFactory.MultiLineIfBlock(SyntaxFactory.IfStatement(condition).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)))
                                  .WithStatements(statements);
                    }
                    else
                    {
                        elseIfs.Add(SyntaxFactory.ElseIfBlock(SyntaxFactory.ElseIfStatement(condition).WithThenKeyword(SyntaxFactory.Token(SyntaxKind.ThenKeyword)), statements));
                    }
                }

                ifBlock = ifBlock.WithElseIfBlocks(SyntaxFactory.List(elseIfs));
                if (defaultElse != null)
                {
                    ifBlock = ifBlock.WithElseBlock(defaultElse);
                }
                ifBlock = ifBlock.WithLeadingTrivia(node.GetLeadingTrivia().Concat(ifBlock.GetLeadingTrivia())).WithTrailingTrivia(node.GetTrailingTrivia())
                          .WithElseBlock(defaultElse).WithAdditionalAnnotations(Formatter.Annotation);

                return(Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(node, ifBlock))));
            })
                );
        }