/// <summary>
/// Rewrites the statement with a raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var invocation = node.Expression as InvocationExpressionSyntax;
var arguments = new List<ArgumentSyntax>();
arguments.Add(invocation.ArgumentList.Arguments[0]);
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"typeof(" + arguments[0].ToString() + ")"));
invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(arguments)));
var text = "{ " +
node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Goto"))).ToString() +
"return; }";
var rewritten = SyntaxFactory.ParseStatement(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
/// <summary>
/// Rewrites the statement with a raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var invocation = node.Expression as InvocationExpressionSyntax;
var arguments = new List<ArgumentSyntax>(invocation.ArgumentList.Arguments);
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"new " + arguments[0].ToString() + "()"));
invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(arguments)));
var rewritten = node.
WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise")))
.WithTriviaFrom(node);
this.RaiseStmts.Add(rewritten);
rewritten = rewritten.WithoutTrailingTrivia();
return rewritten;
}
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node)
{
SyntaxNode result = Visit(node.Expression);
if (result == null)
return null;
return result is ExpressionSyntax ? node.WithExpression((ExpressionSyntax)result) : result;
}
/// <summary>
/// Rewrites the statement with a raise statement.
/// </summary>
/// <param name="node">ExpressionStatementSyntax</param>
/// <returns>SyntaxNode</returns>
private SyntaxNode RewriteStatement(ExpressionStatementSyntax node)
{
var invocation = node.Expression as InvocationExpressionSyntax;
var arguments = new List<ArgumentSyntax>();
arguments.Add(invocation.ArgumentList.Arguments[0]);
string payload = "";
for (int i = 1; i < invocation.ArgumentList.Arguments.Count; i++)
{
if (i == invocation.ArgumentList.Arguments.Count - 1)
{
payload += invocation.ArgumentList.Arguments[i].ToString();
}
else
{
payload += invocation.ArgumentList.Arguments[i].ToString() + ", ";
}
}
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"new " + arguments[0].ToString() + "(" + payload + ")"));
invocation = invocation.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(arguments)));
var text = "{ " +
node.WithExpression(invocation.WithExpression(SyntaxFactory.IdentifierName("this.Raise"))).ToString() +
"return; }";
var rewritten = SyntaxFactory.ParseStatement(text);
rewritten = rewritten.WithTriviaFrom(node);
return rewritten;
}
/// <summary>
/// Normalizes the <paramref name="statement" />.
/// </summary>
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax statement)
{
if (!statement.Expression.IsKind(SyntaxKind.InvocationExpression))
return statement;
var expression = (InvocationExpressionSyntax)statement.Expression;
var methodSymbol = expression.GetReferencedSymbol<IMethodSymbol>(SemanticModel);
if (!methodSymbol.IsBindMethod(SemanticModel))
return statement;
var requiredPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[0].Expression;
var providedPortReferenceExpression = (InvocationExpressionSyntax)expression.ArgumentList.Arguments[1].Expression;
var requiredPorts = requiredPortReferenceExpression.ResolvePortReferences(SemanticModel);
var providedPorts = providedPortReferenceExpression.ResolvePortReferences(SemanticModel);
requiredPorts.RemoveWhere(symbol => !symbol.IsRequiredPort(SemanticModel));
providedPorts.RemoveWhere(symbol => symbol.IsRequiredPort(SemanticModel));
if (methodSymbol.Arity == 1)
{
var delegateType = (INamedTypeSymbol)methodSymbol.TypeArguments[0];
MethodSymbolFilter.Filter(requiredPorts, delegateType);
MethodSymbolFilter.Filter(providedPorts, delegateType);
}
else
MethodSymbolFilter.Filter(requiredPorts, providedPorts);
// The analyzer guarantees that there is exactly one port in each set now, but just to be sure...
Assert.That(requiredPorts.Count == 1, "Expected exactly one required port at this point.");
Assert.That(providedPorts.Count == 1, "Expected exactly one provided port at this point.");
var requiredPortExpression = requiredPortReferenceExpression.ArgumentList.Arguments[0].Expression;
var providedPortExpression = providedPortReferenceExpression.ArgumentList.Arguments[0].Expression;
var requiredPortReference = CreatePortReference(requiredPorts.Single(), requiredPortExpression);
var providedPortReference = CreatePortReference(providedPorts.Single(), providedPortExpression);
var binderType = Syntax.TypeExpression(SemanticModel.GetTypeSymbol(typeof(PortBinding)));
var binderInstance = Syntax.ObjectCreationExpression(binderType, requiredPortReference, providedPortReference);
var bindMemberAccess = Syntax.MemberAccessExpression(binderInstance, nameof(PortBinding.Bind));
var invocation = (ExpressionSyntax)Syntax.InvocationExpression(bindMemberAccess);
return statement.WithExpression(invocation).NormalizeWhitespace().WithTrivia(statement).PrependLineDirective(statement.GetLineNumber());
}