Moq.CustomDelegateCodeFix.SetupDelegateCodeAction.FindSetup(Microsoft.CodeAnalysis.SyntaxNode)

Here are the examples of the csharp api Moq.CustomDelegateCodeFix.SetupDelegateCodeAction.FindSetup(Microsoft.CodeAnalysis.SyntaxNode) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1 Examples 7

19 Source : CustomDelegateCodeFix.cs
with MIT License
from moq

protected override async Task<Doreplacedent> GetChangedDoreplacedentAsync(CancellationToken cancellationToken)
            {
                var generator = SyntaxGenerator.GetGenerator(doreplacedent);
                var root = await setup.SyntaxTree.GetRootAsync(cancellationToken);
                var node = FindSetup(root);
                var member = setup.Ancestors().First(x => generator.GetDeclarationKind(x) == DeclarationKind.Method);
                var @clreplaced = member.Ancestors().First(x => generator.GetDeclarationKind(x) == DeclarationKind.Clreplaced);
                var @delegate = generator.GetMembers(@clreplaced)
                    // Just check by name for now. Might need to also ensure signature compatibility.
                    .FirstOrDefault(x => generator.GetName(x) == symbol.Name);

                var delegateName = symbol.Name;
                var signature = generator.DelegateDeclaration(
                        delegateName,
                        parameters: symbol.Parameters.Select(prm => generator.ParameterDeclaration(prm)),
                        returnType: symbol.ReturnsVoid ? null : generator.TypeExpression(symbol.ReturnType));

                if (@delegate == null)
                {
                    root = root.InsertNodesAfter(member, new[] { signature });
                    // Find the updated setup
                    node = FindSetup(root);
                }
                else
                {
                    var tempDoc = doreplacedent.WithSyntaxRoot(generator.ReplaceNode(root, @delegate, signature));
                    tempDoc = await Simplifier.ReduceAsync(tempDoc);
                    var tempRoot = await tempDoc.GetSyntaxRootAsync(cancellationToken);
                    if (tempRoot == null)
                        return doreplacedent;

                    var clreplacedName = generator.GetName(@clreplaced);
                    var tempClreplaced = tempRoot.DescendantNodes().First(x =>
                        generator.GetDeclarationKind(x) == DeclarationKind.Clreplaced &&
                        generator.GetName(x) == clreplacedName);
                    var tempDelegate = generator.GetMembers(tempClreplaced)
                        .First(x => generator.GetName(x) == delegateName);

                    if ([email protected](tempDelegate, true))
                    {
                        // Generate the delegate name using full Type+Member name.
                        var semantic = await doreplacedent.GetSemanticModelAsync(cancellationToken);
                        if (semantic == null)
                            return doreplacedent;

                        SyntaxNode? memberNode = setup.IsKind(Microsoft.Codereplacedysis.CSharp.SyntaxKind.InvocationExpression) ?
                            ((setup as CS.InvocationExpressionSyntax)?.Expression as CS.MemberAccessExpressionSyntax)?.Expression :
                            ((setup as VB.InvocationExpressionSyntax)?.Expression as VB.MemberAccessExpressionSyntax)?.Expression;

                        if (memberNode == null)
                            return doreplacedent;

                        var mock = semantic.GetSymbolInfo(memberNode);

                        if (mock.Symbol != null &&
                            (mock.Symbol.Kind == SymbolKind.Local ||
                             mock.Symbol.Kind == SymbolKind.Field))
                        {
                            var type = mock.Symbol.Kind == SymbolKind.Local ?
                                ((ILocalSymbol)mock.Symbol).Type :
                                ((IFieldSymbol)mock.Symbol).Type;

                            delegateName = type.MetadataName + symbol.Name;
                            signature = generator.WithName(signature, delegateName);
                            root = root.InsertNodesAfter(member, new[] { signature });
                            // Find the updated setup
                            node = FindSetup(root);
                        }
                    }
                }

                root = generator.ReplaceNode(root, node, generator.WithTypeArguments(node, generator.IdentifierName(delegateName)));
                // Find the updated setup
                node = FindSetup(root);
                if (node == null || node.Parent == null)
                    return doreplacedent;

                // Detect recursive mock access and wrap in a Func<TDelegate>
                if (node.Parent.ChildNodes()
                        .OfType<CS.ArgumentListSyntax>()
                        .Where(list => !list.Arguments.Select(arg => arg.Expression).OfType<CS.LambdaExpressionSyntax>().Any())
                        .SelectMany(list => list.DescendantNodes().OfType<CS.MemberAccessExpressionSyntax>())
                        .Count() > 1 ||
                    node.Parent.ChildNodes()
                        .OfType<VB.ArgumentListSyntax>()
                        .Where(list => !list.Arguments.Select(arg => arg.GetExpression()).OfType<VB.LambdaExpressionSyntax>().Any())
                        .SelectMany(list => list.DescendantNodes().OfType<VB.MemberAccessExpressionSyntax>())
                        .Count() > 1)
                {
                    var expression = node.Parent.ChildNodes().Last()
                        .DescendantNodes()
                        .Where(x =>
                            x.IsKind(Microsoft.Codereplacedysis.CSharp.SyntaxKind.SimpleMemberAccessExpression) ||
                            // For VB, we actually wrap the AddressOf
                            x.IsKind(Microsoft.Codereplacedysis.VisualBasic.SyntaxKind.AddressOfExpression))
                        .First();

                    root = generator.ReplaceNode(root, expression,
                        generator.ValueReturningLambdaExpression(expression));
                    // Find the updated setup
                    node = FindSetup(root);
                    if (node == null || node.Parent == null)
                        return doreplacedent;
                }

                // If there is no Returns, generate one
                if (node.Parent?.Parent != null &&
                    node.Parent.Parent.IsKind(Microsoft.Codereplacedysis.CSharp.SyntaxKind.ExpressionStatement))
                {
                    var returns = (CS.InvocationExpressionSyntax)generator.InvocationExpression(
                        generator.MemberAccessExpression(
                            node.Parent.WithTrailingTrivia(
                                node.Parent.Parent.GetLeadingTrivia().Add(CSFactory.Whitespace("\t"))),
                            "Returns"),
                        generator.ValueReturningLambdaExpression(
                            symbol.Parameters.Select(prm => generator.ParameterDeclaration(prm)),
                            generator.ThrowExpression(generator.NullLiteralExpression())));

                    // Replace the parent InvocationExpression with the returning one.
                    root = generator.ReplaceNode(root, node.Parent, returns);

                    // Find the updated setup
                    node = FindSetup(root);

                    var statement = node.Ancestors().OfType<CS.ExpressionStatementSyntax>().FirstOrDefault();
                    if (statement != null &&
                        (statement.GetTrailingTrivia().Count == 0 ||
                        !statement.GetTrailingTrivia().Any(t => t.Token == statement.SemicolonToken)))
                    {
                        root = generator.ReplaceNode(root, statement, statement
                            .WithSemicolonToken(CSFactory.Token(Microsoft.Codereplacedysis.CSharp.SyntaxKind.SemicolonToken)
                            .WithTrailingTrivia(statement.GetTrailingTrivia().Insert(0, CSFactory.ElasticCarriageReturnLineFeed))));
                    }
                }
                else if (node.Parent?.Parent != null &&
                    node.Parent.Parent.IsKind(Microsoft.Codereplacedysis.VisualBasic.SyntaxKind.ExpressionStatement))
                {
                    var lambda = VBFactory.MultiLineFunctionLambdaExpression(
                        VBFactory.FunctionLambdaHeader().WithParameterList(
                            VBFactory.ParameterList(
                                VBFactory.SeparatedList(
                                    symbol.Parameters.Select(prm => (VB.ParameterSyntax)generator.ParameterDeclaration(prm))))),
                        VBFactory.List(new VB.StatementSyntax[]
                        {
                            VBFactory.ThrowStatement(
                                VBFactory.ObjectCreationExpression(
                                    VBFactory.ParseTypeName(nameof(NotImplementedException))))
                        }),
                        VBFactory.EndFunctionStatement());

                    var returns = generator.InvocationExpression(
                        generator.MemberAccessExpression(
                            node.Parent.WithTrailingTrivia(
                                node.Parent.Parent.GetLeadingTrivia()
                                    .Insert(0, VBFactory.Whitespace(" "))
                                    .Insert(1, VBFactory.LineContinuationTrivia(""))
                                    .Add(VBFactory.Whitespace("\t"))),
                            "Returns"),
                        lambda);

                    // Replace the parent InvocationExpression with the returning one.
                    root = generator.ReplaceNode(root, node.Parent, returns);
                }

                return doreplacedent.WithSyntaxRoot(root);
            }