private async Task <Compilation> BuildDeclarationCompilationFromInProgressAsync(
SolutionState solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
try
{
Debug.Assert(inProgressCompilation != null);
var intermediateProjects = state.IntermediateProjects;
while (intermediateProjects.Length > 0)
{
cancellationToken.ThrowIfCancellationRequested();
var intermediateProject = intermediateProjects[0];
var inProgressProject = intermediateProject.Item1;
var action = intermediateProject.Item2;
inProgressCompilation = await action.InvokeAsync(inProgressCompilation, cancellationToken).ConfigureAwait(false);
intermediateProjects = intermediateProjects.RemoveAt(0);
this.WriteState(State.Create(inProgressCompilation, intermediateProjects), solution);
}
return(inProgressCompilation);
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private async Task <Compilation> BuildDeclarationCompilationFromInProgressAsync(
Solution solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
Contract.Requires(inProgressCompilation != null);
var intermediateProjects = state.IntermediateProjects;
while (intermediateProjects.Length > 0)
{
cancellationToken.ThrowIfCancellationRequested();
var intermediateProject = intermediateProjects[0];
var inProgressProject = intermediateProject.Item1;
var action = intermediateProject.Item2;
inProgressCompilation = await action.InvokeAsync(inProgressCompilation, cancellationToken).ConfigureAwait(false);
intermediateProjects = intermediateProjects.RemoveAt(0);
this.WriteState(State.Create(
this.Retain(solution, inProgressCompilation),
intermediateProjects));
}
return(inProgressCompilation);
}
private async Task <Compilation> BuildFinalStateFromInProgressStateAsync(
Solution solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
var compilation = await BuildDeclarationCompilationFromInProgressAsync(solution, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
return(await FinalizeCompilationAsync(solution, compilation, cancellationToken).ConfigureAwait(false));
}
private InProgressState ClearInProgressState()
{
lock (_gate)
{
var state = _stateDoNotAccessDirectly;
_stateDoNotAccessDirectly = null;
return(state);
}
}
public Message(int maxRetries)
{
PendingState = new PendingState(this);
QueuedState = new QueuedState(this);
InProgressState = new InProgressState(this);
FailedState = new FailedState(this);
CompletedState = new CompletedState(this);
State = PendingState;
MaxRetries = maxRetries;
Retries = -1;
}
private async Task <CompilationInfo> BuildFinalStateFromInProgressStateAsync(
SolutionState solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
try
{
var compilation = await BuildDeclarationCompilationFromInProgressAsync(solution, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
return(await FinalizeCompilationAsync(solution, compilation, cancellationToken).ConfigureAwait(false));
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private InProgressState GetOrCreateInProgressState()
{
lock (_gate)
{
if (_stateDoNotAccessDirectly == null)
{
// here, we take current snapshot of solution when the state is first created. and through out this code, we use this snapshot.
// since we have no idea what actual snapshot of solution the out of proc build has picked up, it doesn't remove the race we can have
// between build and diagnostic service, but this at least make us to consistent inside of our code.
_stateDoNotAccessDirectly = new InProgressState(this, _workspace.CurrentSolution);
}
return(_stateDoNotAccessDirectly);
}
}
private async Task<Compilation> BuildDeclarationCompilationFromInProgressAsync(
Solution solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
Contract.Requires(inProgressCompilation != null);
var intermediateProjects = state.IntermediateProjects;
while (intermediateProjects.Count > 0)
{
cancellationToken.ThrowIfCancellationRequested();
var intermediateProject = intermediateProjects[0];
var inProgressProject = intermediateProject.Item1;
var action = intermediateProject.Item2;
inProgressCompilation = await action.InvokeAsync(inProgressCompilation, cancellationToken).ConfigureAwait(false);
intermediateProjects = intermediateProjects.RemoveAt(0);
this.WriteState(State.Create(
this.Retain(solution, inProgressCompilation),
intermediateProjects));
}
return inProgressCompilation;
}
private async Task<Compilation> BuildFinalStateFromInProgressStateAsync(
Solution solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
var compilation = await BuildDeclarationCompilationFromInProgressAsync(solution, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
return await FinalizeCompilationAsync(solution, compilation, cancellationToken).ConfigureAwait(false);
}
private async Task SyncBuildErrorsAndReportAsync(DiagnosticAnalyzerService diagnosticService, InProgressState inProgressState)
{
var solution = inProgressState.Solution;
var map = await inProgressState.GetLiveDiagnosticsPerProjectAsync().ConfigureAwait(false);
// make those errors live errors
await diagnosticService.SynchronizeWithBuildAsync(_workspace, map).ConfigureAwait(false);
// raise events for ones left-out
var buildErrors = GetBuildErrors().Except(map.Values.SelectMany(v => v)).GroupBy(k => k.DocumentId);
foreach (var group in buildErrors)
{
if (group.Key == null)
{
foreach (var projectGroup in group.GroupBy(g => g.ProjectId))
{
Contract.ThrowIfNull(projectGroup.Key);
ReportBuildErrors(projectGroup.Key, solution, projectGroup.ToImmutableArray());
}
continue;
}
ReportBuildErrors(group.Key, solution, group.ToImmutableArray());
}
}
private async Task<Compilation> BuildDeclarationCompilationFromInProgressAsync(
SolutionState solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
try
{
Contract.Requires(inProgressCompilation != null);
var intermediateProjects = state.IntermediateProjects;
while (intermediateProjects.Length > 0)
{
cancellationToken.ThrowIfCancellationRequested();
var intermediateProject = intermediateProjects[0];
var inProgressProject = intermediateProject.Item1;
var action = intermediateProject.Item2;
inProgressCompilation = await action.InvokeAsync(inProgressCompilation, cancellationToken).ConfigureAwait(false);
intermediateProjects = intermediateProjects.RemoveAt(0);
this.WriteState(State.Create(inProgressCompilation, intermediateProjects), solution);
}
return inProgressCompilation;
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private async Task<CompilationInfo> BuildFinalStateFromInProgressStateAsync(
SolutionState solution, InProgressState state, Compilation inProgressCompilation, CancellationToken cancellationToken)
{
try
{
var compilation = await BuildDeclarationCompilationFromInProgressAsync(solution, state, inProgressCompilation, cancellationToken).ConfigureAwait(false);
return await FinalizeCompilationAsync(solution, compilation, cancellationToken).ConfigureAwait(false);
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
