Connect code to using statement with Roslyn - roslyn

Question

Is there anyway to connect a piece of code to its "using" statement using the Roslyn framework?
For example, given this piece of code:
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Serilog;
using System.Collections.Generic;
namespace CodeAnalyzer.Service.CodeAnalysis.CSharp
{
public static class CSharpCodeAnalyser
{
/// <summary>
/// Retrieves all of the using statements from a code page
/// </summary>
/// <param name="codeDocument"></param>
/// <param name="logger"></param>
/// <returns></returns>
public static List<string> IdentifyUsings(string codeDocument, ILogger logger)
{
var usingList = new List<string>();
try
{
SyntaxTree tree = CSharpSyntaxTree.ParseText(codeDocument);
CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
foreach (var item in root.Usings)
{
usingList.Add(item.Name.ToString());
}
}
catch (System.Exception ex)
{
logger.Error(ex, ex.Message);
throw;
}
return usingList;
}
}
}
Could I know what assembly "CSharpSyntaxTree" belongs to?

Answer 1

So I figured out how to do this.
First I needed to build a workspace containing my entire solution. I did this through the Buildalyzer tool
public static Tuple<AdhocWorkspace, IEnumerable<Project>> GetWorkspace(string solutionFilePath, ILogger logger)
{
Tuple<AdhocWorkspace, IEnumerable<Project>> results;
var projectList = new List<Project>();
AdhocWorkspace workspace = new AdhocWorkspace();
try
{
AnalyzerManager manager = new AnalyzerManager(solutionFilePath);
foreach (var project in manager.Projects)
{
projectList.Add(project.Value.AddToWorkspace(workspace));
}
results = new Tuple<AdhocWorkspace, IEnumerable<Project>>(workspace, projectList);
}
catch (Exception ex)
{
logger.Error(ex, ex.Message);
throw;
}
return results;
}
Once I had a workspace all I needed to do was the following:
var workspace = GetWorkspace(solutionName, _logger);
foreach (var project in workspace.Item1.CurrentSolution.Projects)
{
foreach (var document in project.Documents)
{
_logger.Information("");
_logger.Information(project.Name + "\t\t\t" + document.Name);
var semanticModel = await document.GetSemanticModelAsync();
var root = await document.GetSyntaxRootAsync();
foreach (var item in root.DescendantNodes())
{
var typeInfo = semanticModel.GetTypeInfo(item);
if (typeInfo.Type != null)
{
_logger.Information(String.Format("Node: {0}", item.ToString()));
_logger.Information(String.Format("Type:{0}", typeInfo.Type.Name.ToString()));
_logger.Information(String.Format("ContainingAssembly:{0}", typeInfo.Type.ContainingAssembly));
_logger.Information(String.Format("ContainingNamespace:{0}", typeInfo.Type.ContainingNamespace));
}
}
}
}