public static void ComputeRefactorings(RefactoringContext context, SyntaxToken semicolonToken)
        {
            if (!semicolonToken.IsKind(SyntaxKind.SemicolonToken))
            {
                return;
            }

            if (semicolonToken.IsMissing)
            {
                return;
            }

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandExpressionBody))
            {
                ArrowExpressionClauseSyntax arrowExpressionClause = GetArrowExpressionClause(semicolonToken);

                if (arrowExpressionClause?.IsMissing == false &&
                    ExpandExpressionBodyAnalysis.IsFixable(arrowExpressionClause))
                {
                    context.RegisterRefactoring(
                        "Expand expression body",
                        cancellationToken => ExpandExpressionBodyRefactoring.RefactorAsync(context.Document, arrowExpressionClause, cancellationToken));
                }
            }
        }
        public static async Task <Document> RefactorAsync(
            Document document,
            MemberDeclarationListSelection selectedMembers,
            CancellationToken cancellationToken)
        {
            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            IEnumerable <MemberDeclarationSyntax> newMembers = selectedMembers
                                                               .UnderlyingList
                                                               .ModifyRange(
                selectedMembers.FirstIndex,
                selectedMembers.Count,
                member =>
            {
                ArrowExpressionClauseSyntax expressionBody = CSharpUtility.GetExpressionBody(member);

                if (expressionBody != null &&
                    ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                {
                    return((MemberDeclarationSyntax)Refactor(expressionBody, semanticModel, cancellationToken)
                           .WithFormatterAnnotation());
                }

                return(member);
            });

            return(await document.ReplaceMembersAsync(SyntaxInfo.MemberDeclarationListInfo(selectedMembers.Parent), newMembers, cancellationToken).ConfigureAwait(false));
        }
        public static void ComputeRefactorings(RefactoringContext context, SyntaxToken semicolonToken)
        {
            if (!semicolonToken.IsKind(SyntaxKind.SemicolonToken))
            {
                return;
            }

            if (semicolonToken.IsMissing)
            {
                return;
            }

            if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertExpressionBodyToBlockBody))
            {
                ArrowExpressionClauseSyntax arrowExpressionClause = GetArrowExpressionClause(semicolonToken);

                if (arrowExpressionClause?.IsMissing == false &&
                    ExpandExpressionBodyAnalysis.IsFixable(arrowExpressionClause))
                {
                    context.RegisterRefactoring(
                        ConvertExpressionBodyToBlockBodyRefactoring.Title,
                        ct => ConvertExpressionBodyToBlockBodyRefactoring.RefactorAsync(context.Document, arrowExpressionClause, ct),
                        RefactoringDescriptors.ConvertExpressionBodyToBlockBody);
                }
            }
        }
Exemple #4
0
        public static void ComputeRefactorings(RefactoringContext context, ArrowExpressionClauseSyntax arrowExpressionClause)
        {
            ExpressionSyntax expression = arrowExpressionClause.Expression;

            if (context.IsRefactoringEnabled(RefactoringDescriptors.ConvertExpressionBodyToBlockBody) &&
                (context.Span.IsEmptyAndContainedInSpan(arrowExpressionClause) || context.Span.IsBetweenSpans(expression)) &&
                ExpandExpressionBodyAnalysis.IsFixable(arrowExpressionClause))
            {
                context.RegisterRefactoring(
                    ConvertExpressionBodyToBlockBodyRefactoring.Title,
                    ct => ConvertExpressionBodyToBlockBodyRefactoring.RefactorAsync(context.Document, arrowExpressionClause, ct),
                    RefactoringDescriptors.ConvertExpressionBodyToBlockBody);
            }
        }
Exemple #5
0
        public static async Task ComputeRefactoringsAsync(RefactoringContext context, ArrowExpressionClauseSyntax arrowExpressionClause)
        {
            ExpressionSyntax expression = arrowExpressionClause.Expression;

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.CallToMethod))
            {
                await ReturnExpressionRefactoring.ComputeRefactoringsAsync(context, expression).ConfigureAwait(false);
            }

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandExpressionBody) &&
                (context.Span.IsEmptyAndContainedInSpan(arrowExpressionClause) || context.Span.IsBetweenSpans(expression)) &&
                ExpandExpressionBodyAnalysis.IsFixable(arrowExpressionClause))
            {
                context.RegisterRefactoring(
                    "Expand expression body",
                    cancellationToken => ExpandExpressionBodyRefactoring.RefactorAsync(context.Document, arrowExpressionClause, cancellationToken));
            }
        }
        private static RefactoringDescriptor GetRefactoringDescriptor(MemberDeclarationSyntax memberDeclaration)
        {
            switch (memberDeclaration)
            {
            case MethodDeclarationSyntax methodDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = methodDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringDescriptors.ConvertExpressionBodyToBlockBody);
                    }
                }
                else if (ConvertBlockBodyToExpressionBodyRefactoring.CanRefactor(methodDeclaration))
                {
                    return(RefactoringDescriptors.ConvertBlockBodyToExpressionBody);
                }

                return(default);
            }
        private static string GetRefactoringId(MemberDeclarationSyntax memberDeclaration)
        {
            switch (memberDeclaration)
            {
            case MethodDeclarationSyntax methodDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = methodDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(methodDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case PropertyDeclarationSyntax propertyDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(propertyDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case IndexerDeclarationSyntax indexerDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = indexerDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(indexerDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case OperatorDeclarationSyntax operatorDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = operatorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(operatorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case ConversionOperatorDeclarationSyntax conversionOperatorDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = conversionOperatorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(conversionOperatorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case ConstructorDeclarationSyntax constructorDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = constructorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(constructorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case DestructorDeclarationSyntax destructorDeclaration:
            {
                ArrowExpressionClauseSyntax expressionBody = destructorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(destructorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }
            }

            return(null);
        }
Exemple #8
0
        private static string GetRefactoringId(MemberDeclarationSyntax memberDeclaration)
        {
            switch (memberDeclaration.Kind())
            {
            case SyntaxKind.MethodDeclaration:
            {
                var methodDeclaration = (MethodDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = methodDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(methodDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.PropertyDeclaration:
            {
                var propertyDeclaration = (PropertyDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = propertyDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(propertyDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.IndexerDeclaration:
            {
                var indexerDeclaration = (IndexerDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = indexerDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(indexerDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.OperatorDeclaration:
            {
                var operatorDeclaration = (OperatorDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = operatorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(operatorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.ConversionOperatorDeclaration:
            {
                var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = conversionOperatorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(conversionOperatorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.ConstructorDeclaration:
            {
                var constructorDeclaration = (ConstructorDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = constructorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(constructorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }

            case SyntaxKind.DestructorDeclaration:
            {
                var destructorDeclaration = (DestructorDeclarationSyntax)memberDeclaration;

                ArrowExpressionClauseSyntax expressionBody = destructorDeclaration.ExpressionBody;

                if (expressionBody != null)
                {
                    if (ExpandExpressionBodyAnalysis.IsFixable(expressionBody))
                    {
                        return(RefactoringIdentifiers.ExpandExpressionBody);
                    }
                }
                else if (UseExpressionBodiedMemberRefactoring.CanRefactor(destructorDeclaration))
                {
                    return(RefactoringIdentifiers.UseExpressionBodiedMember);
                }

                return(null);
            }
            }

            return(null);
        }