예제 #1
0
        private static InvocationExpressionSyntax SplitLinqWhereInvocation(
            InvocationExpressionSyntax invocation,
            SimpleLambdaExpressionSyntax filter)
        {
            var filterParameter  = filter.Parameter;
            var filterExpression = (ExpressionSyntax)filter.Body;

            var factors = FactorizeExpression(filterExpression);

            var newInvocation = ExtendedSyntaxFactory.MakeInvocationWithLambdaArgument(
                invocation.Expression,
                filterParameter,
                factors[0]);

            for (int i = 1; i < factors.Count; ++i)
            {
                var memberAccess = SyntaxFactory.MemberAccessExpression(
                    SyntaxKind.SimpleMemberAccessExpression,
                    newInvocation,
                    SyntaxFactory.IdentifierName(LinqHelper.WhereMethodName));

                newInvocation = ExtendedSyntaxFactory.MakeInvocationWithLambdaArgument(
                    memberAccess,
                    filterParameter,
                    factors[i]);
            }

            return(newInvocation.WithTriviaFrom(invocation));
        }
예제 #2
0
        private static InvocationExpressionSyntax SplitFunctionComposition(
            InvocationExpressionSyntax selectInvocation,
            SimpleLambdaExpressionSyntax projection,
            InvocationExpressionSyntax[] invocationStack,
            SemanticModel semanticModel)
        {
            var lambdaParameter = projection.Parameter;
            var parameterName   = lambdaParameter.Identifier.Text;
            var parameterSymbol = semanticModel.GetDeclaredSymbol(lambdaParameter);

            Func <InvocationExpressionSyntax, bool> isNeedToReplaceInvocation = i =>
                                                                                DataFlowAnalysisHelper.IsIdentifierReferencedIn(
                parameterName,
                parameterSymbol,
                semanticModel,
                i);

            var newSelectInvocation = ExtendedSyntaxFactory.MakeInvocationWithLambdaArgument(
                selectInvocation.Expression,
                lambdaParameter,
                invocationStack[0]);

            var invocationReplacer = new InvocationReplacer(
                isNeedToReplaceInvocation,
                SyntaxFactory.IdentifierName(parameterName));

            for (int i = 1; i < invocationStack.Length; ++i)
            {
                var innerInvocation = invocationStack[i];

                var processedInnerInvocation = ReplaceInvocationsInArguments(
                    innerInvocation,
                    invocationReplacer);

                var memberAccess = SyntaxFactory.MemberAccessExpression(
                    SyntaxKind.SimpleMemberAccessExpression,
                    newSelectInvocation,
                    SyntaxFactory.IdentifierName(LinqHelper.SelectMethodName));

                newSelectInvocation = ExtendedSyntaxFactory.MakeInvocationWithLambdaArgument(
                    memberAccess,
                    lambdaParameter,
                    processedInnerInvocation);
            }

            return(newSelectInvocation.WithTriviaFrom(selectInvocation));
        }