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
19
Source : CustomDelegateCodeFix.cs
with MIT License
from moq
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);
}