private static ExpressionStatementSyntax RewriteOfType(this ExpressionStatementSyntax expression, string from,
string to)
{
Func <InvocationExpressionSyntax, InvocationExpressionSyntax> func = (i) =>
{
if (!(i.Expression is MemberAccessExpressionSyntax mae))
{
return(i);
}
var oldArguments = i.ArgumentList.Arguments;
//I promise oldArgs.OfType<TypeOfExpressionSyntax>() does not work... but not sure why. TODO: be more elegant
var argument = oldArguments.First(t => t.ToString().StartsWith("typeof"));
if (!(argument?.Expression is TypeOfExpressionSyntax typeofExpr))
{
return(i);
}
var genericName = GenericName(
ParseToken(to),
TypeArgumentList(SingletonSeparatedList(typeofExpr.Type)));
var newArgs = i.ArgumentList.WithArguments(oldArguments.Remove(argument));
return(i.WithExpression(mae.WithName(genericName)).WithArgumentList(newArgs));
};
return(expression.ExpressionRewriter(model: null, from: from, to: to, func: func));
}
internal static ExpressionStatementSyntax RewriteFail(this ExpressionStatementSyntax expression)
{
InvocationExpressionSyntax Func(InvocationExpressionSyntax i)
{
var args = i.ArgumentList.Arguments.Insert(0, Argument(ParseExpression("false")));
return(i.WithArgumentList(i.ArgumentList.WithArguments(args)));
}
expression = expression.ExpressionRewriter(model: null, from: "Assert.Fail", to: "True",
func: (Func <InvocationExpressionSyntax, InvocationExpressionSyntax>)Func);
//TODO: Using the Formatter.Annotation like this seems like a smell, I'd rather make it a parameter to this function.
return(expression.WithAdditionalAnnotations(Formatter.Annotation));
}
internal static ExpressionStatementSyntax RewriteMappedExpression(this ExpressionStatementSyntax expression,
SemanticModel model)
{
if (!(expression.Expression is InvocationExpressionSyntax invocation))
{
return(expression);
}
var from = invocation.Expression.ToString();
if (AssertMapping.TryGetValue(from, out var to))
{
return(expression.ExpressionRewriter(model: model, from: from, to: to));
}
else
{
return(expression);
}
}
internal static ExpressionStatementSyntax RewriteContains(this ExpressionStatementSyntax expression)
{
return(expression.ExpressionRewriter(model: null, from: "StringAssert.Contains", to: "Assert.Contains",
identifier: IdentifierName("Assert")));
}
internal static ExpressionStatementSyntax RewriteInconclusive(this ExpressionStatementSyntax expression)
{
return(expression.ExpressionRewriter(model: null, from: "Assert.Inconclusive", to: "Fail").RewriteFail());
}
