async internal static Task<MethodEntity> FindProviderAndCreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
MethodEntity methodEntity = null;
var pair = await ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodDescriptor);
if (pair != null)
{
var provider = pair.Item1;
var tree = pair.Item2;
var model = provider.Compilation.GetSemanticModel(tree);
var methodEntityGenerator = new MethodSyntaxProcessor(model, provider, tree, methodDescriptor);
methodEntity = methodEntityGenerator.ParseMethod();
}
else
{
var libraryMethodVisitor = new LibraryMethodProcessor(methodDescriptor);
methodEntity = libraryMethodVisitor.ParseLibraryMethod();
}
return methodEntity;
}
/// <summary>
/// Try to get the roslyn methods on the fly
/// Currently works with one project.
/// </summary>
public void AnalyzeOnDemand()
{
Contract.Assert(this.Dispatcher != null);
var cancellationToken = new CancellationTokenSource();
var projectIDs = this.Solution.GetProjectDependencyGraph().GetTopologicallySortedProjects(cancellationToken.Token);
foreach (var projectId in projectIDs)
{
var project = this.Solution.GetProject(projectId);
var compilation = project.GetCompilationAsync().Result;
var triple = ProjectCodeProvider.GetProviderContainingEntryPointAsync(project, cancellationToken.Token).Result;
var provider = triple.Item1;
IMethodSymbol mainSymbol = triple.Item2;
var tree = triple.Item3;
if (provider != null)
{
var model = provider.Compilation.GetSemanticModel(tree);
cancellationToken.Cancel(); // cancel out outstanding processing tasks
var methodVisitor = new MethodSyntaxProcessor(model, tree, mainSymbol);
var mainMethodEntity = methodVisitor.ParseMethod();
this.Dispatcher.RegisterEntity(mainMethodEntity.EntityDescriptor, mainMethodEntity);
var mainEntityProcessor = new MethodEntityProcessor((MethodEntity)mainMethodEntity, this.Dispatcher);
//var mainMethodDescriptor = new MethodDescriptor(mainSymbol);
//var mainMethodEntityDescriptor = EntityFactory.Create(mainMethodDescriptor);
//var mainEntityProcessor = this.Dispatcher.GetEntityWithProcessorAsync(mainMethodEntityDescriptor).Result ;
// Just a test
//mainEntityProcessor.MethodEntity.CurrentContext = new CallConext<AMethod, ANode>(mainEntityProcessor.MethodEntity.Method, null, null);
mainEntityProcessor.DoAnalysis();
Logger.Instance.Log("SolutionAnalyzer", "AnalyzeOnDemand", "--- Done with propagation ---");
}
}
if (this.Dispatcher is QueueingDispatcher)
{
var qd = (QueueingDispatcher)this.Dispatcher;
while (!qd.IsDoneProcessing)
{
Logger.Instance.Log("SolutionAnalyzer", "AnalyzeOnDemand", "Waiting for the queue to empty up...");
Thread.Sleep(1000);
}
}
}
async internal Task<MethodEntity> CreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
MethodEntity methodEntity = null;
var tree = await this.GetSyntaxAsync(methodDescriptor);
if(tree==null)
{ }
var model = this.Compilation.GetSemanticModel(tree);
var methodEntityGenerator = new MethodSyntaxProcessor(model, this, tree, methodDescriptor);
methodEntity = methodEntityGenerator.ParseMethod();
return methodEntity;
}
