/// <summary>
/// Generate a field declaration syntax as if it was declared in a class implementation.
/// </summary>
/// <param name="type">The field type.</param>
/// <param name="name">The field name.</param>
/// <param name="init">The field initializer.</param>
/// <returns>The FieldDeclarationSyntax node.</returns>
public static FieldDeclarationSyntax GetFieldSyntax(string type, string name, string init)
{
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"public {type} {name} = {init};");
return((FieldDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single());
}
/// <summary>
/// Generate a property declaration syntax as if it was declared in a class implementation with
/// an expression body.
/// </summary>
/// <param name="type">The property type.</param>
/// <param name="name">The property name.</param>
/// <param name="expressionBody">The expression body.</param>
/// <returns>The PropertyDeclarationSyntax node.</returns>
public static PropertyDeclarationSyntax GetExpressionBodyPropertyImplSyntax(string type, string name, string expressionBody)
{
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"public {type} {name} => {expressionBody};");
return((PropertyDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single());
}
/// <summary>
/// Generate a syntax node given the declaration use code statement.
/// </summary>
/// <param name="typeStatement">The CSharp code to generate the type syntax node from.</param>
/// <returns>The syntax node.</returns>
public static TypeSyntax GetTypeSyntax(string typeStatement)
{
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"{typeStatement} a;");
var field = (FieldDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single();
return(field.Declaration.Type);
}
/// <summary>
/// Generate a local declaration syntax as if it was declared in a method implementation
/// (for a variable declaration by instance).
/// </summary>
/// <param name="type">The variable type.</param>
/// <param name="name">The variable name.</param>
/// <returns>The VariableDeclarationSyntax node.</returns>
public static LocalDeclarationStatementSyntax GetLocalDeclarationStatementSyntax(string type, string name, string init)
{
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"void Method(){{{type} {name} = {init};}}");
var statementSyntax = ((MethodDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single()).Body.Statements.First();
return((LocalDeclarationStatementSyntax)statementSyntax);
}
private static T AssertSingleMemberOfType <T>(StringBuilder output)
where T : SyntaxNode
{
var resultingNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode(output.ToString());
var cun = Assert.IsType <CompilationUnitSyntax>(resultingNode);
var member = Assert.Single(cun.Members);
return(Assert.IsType <T>(member));
}
/// <summary>
/// Generate a method declaration syntax as if it was declared in a class implementation.
/// </summary>
/// <param name="type">The method return type.</param>
/// <param name="name">The method name.</param>
/// <param name="argument">The argument name.</param>
/// <returns>The MethodDeclarationSyntax node.</returns>
public static MethodDeclarationSyntax GetMethodSyntax(string type, string name, string argument, string otherArguments)
{
if (otherArguments == null)
{
otherArguments = string.Empty;
}
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"public {type} {name}({type} {argument}{otherArguments}){{}}");
return((MethodDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single());
}
private static IReadOnlyList <T> AssertMultiMemberOfType <T>(StringBuilder output)
where T : SyntaxNode
{
var resultingNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode(output.ToString());
var cun = Assert.IsType <CompilationUnitSyntax>(resultingNode);
var results = new List <T>();
foreach (var member in cun.Members)
{
results.Add(Assert.IsType <T>(member));
}
return(results);
}
/// <summary>
/// Generate a property declaration syntax as if it was declared in a class implementation.
/// </summary>
/// <param name="type">The property type.</param>
/// <param name="name">The property name.</param>
/// <param name="field">The field to get or set.</param>
/// <returns>The PropertyDeclarationSyntax node.</returns>
public static PropertyDeclarationSyntax GetPropertyImplSyntax(string type, string name, string field = null)
{
var getImpl = "get;";
var setImpl = "set;";
if (!string.IsNullOrEmpty(field))
{
getImpl = $"get {{ return {field}; }}";
setImpl = $"set {{ {field} = value; }}";
}
var syntaxNode = AReflectionSyntaxNodeProvider <SyntaxNode>
.GetSyntaxNode($"public {type} {name} {{ {getImpl} {setImpl} }}");
return((PropertyDeclarationSyntax)((CompilationUnitSyntax)syntaxNode).Members.Single());
}