public ExpressionStatementSyntax TryReplaceAssignmentExpressionWithMethodCall(ExpressionStatementSyntax node, INamedTypeSymbol typeSymbol = null)
{
// There are 2 cases to consider
// Either we stub a method/property by setting a property; set value being the stub lambda
// Or by invoking a method having a single argument; method argument being the stub lambda
StubbedCall msStub = null;
var assignment = node.ChildNodes().OfType <AssignmentExpressionSyntax>().FirstOrDefault();
if (assignment != null)
{
var member = assignment.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax;
if (member == null)
{
return(null);
}
var resultExpression = assignment.Right;
msStub = StubMsTestMethodOrPropertyCall(assignment, member, resultExpression, typeSymbol);
}
else
{
var invocation = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault();
if (invocation == null)
{
return(null);
}
var member = invocation.ChildNodes().FirstOrDefault() as MemberAccessExpressionSyntax;
if (member == null)
{
return(null);
}
var argument = invocation.ArgumentList.ChildNodes().FirstOrDefault() as ArgumentSyntax;
if (argument == null)
{
return(null);
}
msStub = StubMsTestMethodOrPropertyCall(invocation, member, argument.Expression, typeSymbol);
}
if (msStub != null)
{
var moqStub = MockMethodOrPropertyCall(msStub);
var stubDefinition = SyntaxFactory.ExpressionStatement(moqStub.NewNode)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
return(stubDefinition);
}
return(null);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
var invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()?
.ChildTokens()?.FirstOrDefault().Text;
if (invocationName == null)
{
invocationName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()?
.ChildTokens()?.FirstOrDefault().Text;
}
if (invocationName != null && invocationName.Equals("YIELD", StringComparison.OrdinalIgnoreCase))
{
var genericName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <GenericNameSyntax>().FirstOrDefault()?
.ChildNodes().OfType <TypeArgumentListSyntax>().FirstOrDefault()?
.ChildNodes().OfType <PredefinedTypeSyntax>().FirstOrDefault()?.Keyword.Text;
var varName = node.ChildNodes().OfType <InvocationExpressionSyntax>().FirstOrDefault()?
.ChildNodes().OfType <ArgumentListSyntax>().FirstOrDefault()?
.ChildNodes().OfType <ArgumentSyntax>().FirstOrDefault()?
.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault()?.GetText().ToString();
String type = "var";
if (genericName != null)
{
type = genericName;
}
var leadingTrivia = node.GetLeadingTrivia();
var forEachExp = SyntaxFactory.ForEachStatement(
SyntaxFactory.Token(SyntaxKind.ForEachKeyword),
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
SyntaxFactory.IdentifierName(type),
SyntaxFactory.Identifier("item"),
SyntaxFactory.Token(SyntaxKind.InKeyword),
SyntaxFactory.IdentifierName(varName),
SyntaxFactory.Token(SyntaxKind.CloseParenToken)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine))
.WithTrailingTrivia(leadingTrivia),
SyntaxFactory.Block(
SyntaxFactory.YieldStatement(
SyntaxKind.YieldReturnStatement,
SyntaxFactory.IdentifierName("item").WithLeadingTrivia(leadingTrivia)
)
)).NormalizeWhitespace().WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine));
return(forEachExp);
}
return(base.VisitExpressionStatement(node));
}
private void ParseExpressionStatementDeclaration(ExpressionStatementSyntax expressionStatementSyntax)
{
_output.HandleLeadingTrivia(expressionStatementSyntax);
foreach (var childNode in expressionStatementSyntax.ChildNodes())
{
_output.HandleLeadingTrivia(childNode);
InvocationExpressionSyntax invocationExpressionSyntax = childNode as InvocationExpressionSyntax;
if (invocationExpressionSyntax != null)
{
ParseInvocationExpressionDeclaration(invocationExpressionSyntax);
}
AssignmentExpressionSyntax alignmentExpressionSyntax = childNode as AssignmentExpressionSyntax;
if (alignmentExpressionSyntax != null)
{
_expression.ParseExpressionSyntax(alignmentExpressionSyntax.Left);
ParseOperatorToken(alignmentExpressionSyntax.OperatorToken);
_expression.ParseExpressionSyntax(alignmentExpressionSyntax.Right);
}
_output.HandleTrailingTrivia(childNode);
}
ParseOperatorToken(expressionStatementSyntax.SemicolonToken);
_output.HandleTrailingTrivia(expressionStatementSyntax);
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
SyntaxNode newNode = stub2Moq.TryReplaceAssignmentExpressionWithMethodCall(node);
if (newNode != null)
{
return(newNode);
}
var assignementExpression = node.ChildNodes().OfType <AssignmentExpressionSyntax>().FirstOrDefault();
if (assignementExpression != null)
{
newNode = stub2Moq.SwitchType(assignementExpression);
if (newNode != null)
{
return(newNode);
}
}
return(base.VisitExpressionStatement(node));
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
base.VisitExpressionStatement(node);
// Get the first syntax node.
foreach (SyntaxNode child in node.ChildNodes())
{
// Operations are of invocation expression kind.
if (child.IsKind(SyntaxKind.InvocationExpression))
{
InvocationExpressionSyntax expr = child as InvocationExpressionSyntax;
string exprText = expr.Expression.ToString();
// Split the expression on the dot token.
string[] exprTokens = exprText.Split('.');
//Debug.Assert(exprTokens.Length == 2, "Nested member access.");
// Add the last token as the operation.
macroOperations.Add(exprTokens[exprTokens.Length - 1]);
}
}
}
public override void VisitExpressionStatement(ExpressionStatementSyntax node)
{
base.VisitExpressionStatement(node);
// Get the first syntax node.
foreach (SyntaxNode child in node.ChildNodes())
{
// Operations are of invocation expression kind.
if (child.IsKind(SyntaxKind.InvocationExpression))
{
InvocationExpressionSyntax expr = child as InvocationExpressionSyntax;
string exprText = expr.Expression.ToString();
// Split the expression on the dot token.
string[] exprTokens = exprText.Split('.');
//Debug.Assert(exprTokens.Length == 2, "Nested member access.");
// Add the last token as the operation.
macroOperations.Add(exprTokens[exprTokens.Length - 1]);
}
}
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax expressionNode)
{
if (expressionNode is null)
{
throw new ArgumentNullException(nameof(expressionNode));
}
#region it is what we want?
var invocations = new List <InvocationExpressionSyntax>();
var child = expressionNode
.ChildNodes()
.OfType <InvocationExpressionSyntax>()
.FirstOrDefault()
;
while (child is not null)
{
invocations.Add(child);
var preChild = child
.ChildNodes()
.OfType <MemberAccessExpressionSyntax>()
.FirstOrDefault()
;
if (preChild is null)
{
break;
}
child = preChild
.ChildNodes()
.OfType <InvocationExpressionSyntax>()
.FirstOrDefault()
;
}
if (invocations.Count < 2)
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectClause,
$"Incorrect bind expression"
);
}
invocations.Reverse();
var currentType = _set[typeof(DefaultCluster).ToGlobalDisplayString()];
var invocationSymbols = new List <Tuple <InvocationExpressionSyntax, IMethodSymbol> >();
for (var invocationIndex = 0; invocationIndex < invocations.Count; invocationIndex++)
{
var invocation = invocations[invocationIndex];
var isLast = invocationIndex == (invocations.Count - 1);
var symbol = _semanticModel.GetSymbolInfo(invocation).Symbol;
if (symbol is null)
{
continue;
}
if (symbol is not IMethodSymbol)
{
continue;
}
var setds = symbol.ContainingType.ToGlobalDisplayString();
if (!_set.ContainsKey(setds))
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectClause,
$"Incorrect clause found in bind expression: {setds}"
);
}
var methods = currentType.GetAllNonStaticMethodsHierarchy();
var foundMethod = methods.FirstOrDefault(m => m.Name == symbol.Name);
if (foundMethod is null)
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectClause,
$"Incorrect method found in bind expression: {symbol.Name}"
);
}
if (isLast && invocations.Count == 2)
{
if (symbol.ContainingType.ToGlobalDisplayString() == typeof(IToFactoryBinding).ToGlobalDisplayString())
{
throw new DpdtException(
DpdtExceptionTypeEnum.IncorrectBinding_IncorrectClause,
$"Scope must be defined: {expressionNode}"
);
}
}
currentType = foundMethod.ReturnType;
invocationSymbols.Add(
new Tuple <InvocationExpressionSyntax, IMethodSymbol>(
invocation,
(IMethodSymbol)symbol
)
);
}
#endregion
var pbes = _beFactory.Create(
expressionNode,
invocationSymbols
);
foreach (var pbe in pbes)
{
pbe.Validate();
//looks like we found what we want
var bindingContainer = pbe.CreateBindingContainer(
);
_bindingContainers.Add(bindingContainer);
}
return(expressionNode);
}
