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()); }