private static SyntaxNode addConstructor(SyntaxNode node)
{
var classDeclaration = node as ClassDeclarationSyntax;
Assert.IsTrue(classDeclaration != null);
return(classDeclaration
.AddMembers(CSharp.ConstructorDeclaration(classDeclaration.Identifier)
.WithBody(CSharp.Block())));
}
public override SyntaxNode Visit(SyntaxNode node)
{
var visited = base.Visit(node);
if (node is StatementSyntax stmt && _replacements.StatementReplaces.TryGetValue(stmt, out var replacements))
{
var newStatements = replacements.Select(a => ConvertLambda(a.Lambda))
.Concat(new[] { (StatementSyntax)visited }).ToArray();
var block = SyntaxFactory.Block(newStatements);
return(block);
}
return(visited);
}
public static void NoArgumentNull()
{
StatementSyntax ToStatement(IParameterSymbol parameter)
{
return(F.IfStatement(
F.ParseExpression($"{nameof(ReferenceEquals)}(null, {parameter.Name})"),
F.ParseStatement($"throw new {typeof(ArgumentNullException).FullName}(\"{parameter.Name}\");")
));
}
CallBinder.StatementSyntax = F.Block(
from parameter in CallBinder.CallerSymbol.Parameters
where !parameter.Type.IsValueType
select ToStatement(parameter)
);
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
var visited = (MethodDeclarationSyntax)base.VisitMethodDeclaration(node);
if (node.ExpressionBody != null && _replacements.MethodReplaces.TryGetValue(node, out var replacements))
{
var newStatements = replacements
.Select(a => (StatementSyntax)ConvertLambda(a.Lambda))
.Concat(new[] { SyntaxFactory.ReturnStatement(
visited.ExpressionBody.Expression).NormalizeWhitespace() })
.ToArray();
return(SyntaxFactory.MethodDeclaration(GetDummyMethodReturnType(), visited.Identifier)
.NormalizeWhitespace()
.WithBody(SyntaxFactory.Block(newStatements)));
}
return(visited);
}
public static BlockSyntax GetInvocationBlockSyntax(string delegateTypeName, string methodName, string parameters,
IEnumerable <IParameterSymbol> outParameters, ITypeSymbol returnType, SemanticModel semanticModel)
{
var voidType = semanticModel.Compilation.GetTypeByMetadataName("System.Void");
bool returnsVoid = returnType.Equals(voidType);
var statements = new List <StatementSyntax>();
string returnStatement = returnsVoid ? string.Empty : "return ";
statements.Add(SF.ParseStatement($"{delegateTypeName} del;{System.Environment.NewLine}"));
// Prepare if/else block to determine how uninitialized stubs are handled.
var ifStrictExpression = SF.ParseExpression("MockBehavior == MockBehavior.Strict");
var ifStrictTrueSyntax = SF.Block(SF.ParseStatement($"del = _stubs.GetMethodStub<{delegateTypeName}>(\"{methodName}\");{System.Environment.NewLine}"));
var defaultReturnInvocation = outParameters.Select(p =>
SF.ParseStatement($"{p.Name} = default ({p.Type.GetGenericName()});")).ToList();
if (!returnsVoid)
{
defaultReturnInvocation.Add(SF.ParseStatement(GetDefaultReturnInvocationStatement(returnType, semanticModel)));
}
else
{
defaultReturnInvocation.Add(SF.ParseStatement($"return;{System.Environment.NewLine}"));
}
var ifTryGetMethodStubExpression = SF.ParseExpression($"!_stubs.TryGetMethodStub<{delegateTypeName}>(\"{methodName}\", out del)");
var ifStrictFalseSyntax = SF.Block(SF.IfStatement(ifTryGetMethodStubExpression, SF.Block(defaultReturnInvocation)));
statements.Add(SF.IfStatement(ifStrictExpression, ifStrictTrueSyntax, SF.ElseClause(ifStrictFalseSyntax)));
// Add default invocation.
statements.Add(SF.ParseStatement($"{returnStatement}del.Invoke({parameters});{System.Environment.NewLine}"));
return(SF.Block(statements.ToArray()));
}
public BlockSyntax Build() => SF.Block(SF.List(_statements.Select(s => s.Build())));
public static BlockSyntax ToBlock(this string code)
{
return(SF.Block().AddStatements(code.ToStatments()));
}