/// <summary>
/// Helper method, which compiles <paramref name="syntaxTree"/> to <see cref="Compilation"/> ovject
/// </summary>
/// <param name="syntaxTree"><see cref="SyntaxTree"/> of code to compile</param>
/// <param name="diagnostics">Diagnostic information from this compilation</param>
/// <param name="compilationOptions">All compilation options</param>
/// <returns>Compilation with program</returns>
public static CSharpCompilation Compile(this SyntaxTree syntaxTree,
CompilationOptions compilationOptions,
out IEnumerable <DiagnosticHelper> diagnostics)
{
var compilation = syntaxTree.Compile(compilationOptions);
diagnostics = compilation.GetDiagnostics()
.AsDiagnosticHelper()
.WithAllCustomDiagnostics(syntaxTree,
compilation.GetSemanticModel(syntaxTree));
return(compilation);
}
/// <summary>
/// Extension method for <see cref="SyntaxNode"/> which gets static method need by tests
/// </summary>
/// <param name="root">Assembly in which method should be defined</param>
/// <param name="className">Class name in which method should be defined</param>
/// <param name="methodName">Method name needed by test</param>
/// <param name="parametersType">Method parameters. If null method without parameters will be returned</param>
/// <returns>Described method</returns>
public static MethodDeclarationSyntax GetTestMethod(this SyntaxTree tree,
string className,
string methodName,
Type[] parametersType = null)
=> tree.GetRoot()
.DescendantNodes()
.OfType <ClassDeclarationSyntax>()
.Where(c => c.Identifier.Text == className)
.SelectMany(c => c.DescendantNodes())
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Identifier.Text.Trim() == methodName)
.Where(method => method.Modifiers.Any(t => t.Kind() == SyntaxKind.StaticKeyword))
.FirstOrDefault(method => {
// If there is no given parameters type try to find method without parameters
if (parametersType == null || parametersType.Length == 0)
{
return(method.ParameterList.Parameters.Count == 0);
}
// If number of parameters do not match it means this is not that function
if (parametersType.Length != method.ParameterList.Parameters.Count)
{
return(false);
}
// Finds method in which all parameters are exacly the same
var semanticModel = tree.Compile(DefaultCompilationOptions, out _).GetSemanticModel(tree);
return(!method.ParameterList.Parameters
.Where((t, i) => semanticModel
.GetDeclaredSymbol(method.ParameterList
.Parameters[i])
.Type.Name !=
parametersType[i].Name)
.Any());
});
