private async Task <SolutionStateChecksums> ComputeChecksumsAsync(CancellationToken cancellationToken)
{
try
{
using (Logger.LogBlock(FunctionId.SolutionState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// get states by id order to have deterministic checksum
var orderedProjectIds = ChecksumCache.GetOrCreate(ProjectIds, _ => ProjectIds.OrderBy(id => id.Id).ToImmutableArray());
var projectChecksumTasks = orderedProjectIds.Select(id => ProjectStates[id])
.Where(s => RemoteSupportedLanguages.IsSupported(s.Language))
.Select(s => s.GetChecksumAsync(cancellationToken));
var serializer = _solutionServices.Workspace.Services.GetService <ISerializerService>();
var infoChecksum = serializer.CreateChecksum(SolutionAttributes, cancellationToken);
var optionsChecksum = serializer.CreateChecksum(Options, cancellationToken);
var analyzerReferenceChecksums = ChecksumCache.GetOrCreate <AnalyzerReferenceChecksumCollection>(AnalyzerReferences,
_ => new AnalyzerReferenceChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var projectChecksums = await Task.WhenAll(projectChecksumTasks).ConfigureAwait(false);
return(new SolutionStateChecksums(infoChecksum, optionsChecksum, new ProjectChecksumCollection(projectChecksums), analyzerReferenceChecksums));
}
}
catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
{
throw ExceptionUtilities.Unreachable;
}
}
private async Task <ProjectStateChecksums> ComputeChecksumsAsync(CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.ProjectState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// get states by id order to have deterministic checksum
var documentChecksumsTasks = DocumentIds.Select(id => DocumentStates[id].GetChecksumAsync(cancellationToken));
var additionalDocumentChecksumTasks = AdditionalDocumentIds.Select(id => AdditionalDocumentStates[id].GetChecksumAsync(cancellationToken));
var serializer = new Serializer(_solutionServices.Workspace);
var infoChecksum = serializer.CreateChecksum(ProjectInfo.Attributes, cancellationToken);
// these compiler objects doesn't have good place to cache checksum. but rarely ever get changed.
var compilationOptionsChecksum = SupportsCompilation ? ChecksumCache.GetOrCreate(CompilationOptions, _ => serializer.CreateChecksum(CompilationOptions, cancellationToken)) : Checksum.Null;
var parseOptionsChecksum = SupportsCompilation ? ChecksumCache.GetOrCreate(ParseOptions, _ => serializer.CreateChecksum(ParseOptions, cancellationToken)) : Checksum.Null;
var projectReferenceChecksums = ChecksumCache.GetOrCreate <ProjectReferenceChecksumCollection>(ProjectReferences, _ => new ProjectReferenceChecksumCollection(ProjectReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var metadataReferenceChecksums = ChecksumCache.GetOrCreate <MetadataReferenceChecksumCollection>(MetadataReferences, _ => new MetadataReferenceChecksumCollection(MetadataReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var analyzerReferenceChecksums = ChecksumCache.GetOrCreate <AnalyzerReferenceChecksumCollection>(AnalyzerReferences, _ => new AnalyzerReferenceChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var documentChecksums = await Task.WhenAll(documentChecksumsTasks).ConfigureAwait(false);
var additionalChecksums = await Task.WhenAll(additionalDocumentChecksumTasks).ConfigureAwait(false);
return(new ProjectStateChecksums(
infoChecksum,
compilationOptionsChecksum,
parseOptionsChecksum,
new DocumentChecksumCollection(documentChecksums),
projectReferenceChecksums,
metadataReferenceChecksums,
analyzerReferenceChecksums,
new TextDocumentChecksumCollection(additionalChecksums)));
}
}
private Checksum GetParseOptionsChecksum(ISerializerService serializer) =>
this.SupportsCompilation
? ChecksumCache.GetOrCreate(
this.ParseOptions,
_ => serializer.CreateParseOptionsChecksum(this.ParseOptions)
)
: Checksum.Null;
private static Checksum GetMetadataChecksumSlow(Solution solution, PortableExecutableReference reference, CancellationToken cancellationToken)
{
return(ChecksumCache.GetOrCreate(reference, _ =>
{
var serializer = solution.Workspace.Services.GetService <ISerializerService>();
var checksum = serializer.CreateChecksum(reference, cancellationToken);
return checksum;
}));
}
public static Checksum GetMetadataChecksum(
Solution solution, PortableExecutableReference reference, CancellationToken cancellationToken)
{
// We can reuse the index for any given reference as long as it hasn't changed.
// So our checksum is just the checksum for the PEReference itself.
return(ChecksumCache.GetOrCreate(reference, _ =>
{
var serializer = solution.Workspace.Services.GetService <ISerializerService>();
var checksum = serializer.CreateChecksum(reference, cancellationToken);
return checksum;
}));
}
private static Checksum GetMetadataChecksumSlow(Solution solution, PortableExecutableReference reference, CancellationToken cancellationToken)
{
return(ChecksumCache.GetOrCreate(reference, _ =>
{
var serializer = solution.Workspace.Services.GetService <ISerializerService>();
var checksum = serializer.CreateChecksum(reference, cancellationToken);
// Include serialization format version in our checksum. That way if the
// version ever changes, all persisted data won't match the current checksum
// we expect, and we'll recompute things.
return Checksum.Create(checksum, SerializationFormatChecksum);
}));
}
private async Task <ProjectStateChecksums> ComputeChecksumsAsync(CancellationToken cancellationToken)
{
try
{
using (Logger.LogBlock(FunctionId.ProjectState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// Here, we use the _documentStates and _additionalDocumentStates and visit them in order; we ensure that those are
// sorted by ID so we have a consistent sort.
var documentChecksumsTasks = _documentStates.Select(pair => pair.Value.GetChecksumAsync(cancellationToken));
var additionalDocumentChecksumTasks = _additionalDocumentStates.Select(pair => pair.Value.GetChecksumAsync(cancellationToken));
var analyzerConfigDocumentChecksumTasks = _analyzerConfigDocumentStates.Select(pair => pair.Value.GetChecksumAsync(cancellationToken));
var serializer = _solutionServices.Workspace.Services.GetService <ISerializerService>();
var infoChecksum = serializer.CreateChecksum(ProjectInfo.Attributes, cancellationToken);
// these compiler objects doesn't have good place to cache checksum. but rarely ever get changed.
var compilationOptionsChecksum = SupportsCompilation ? ChecksumCache.GetOrCreate(CompilationOptions, _ => serializer.CreateChecksum(CompilationOptions, cancellationToken)) : Checksum.Null;
cancellationToken.ThrowIfCancellationRequested();
var parseOptionsChecksum = GetParseOptionsChecksum(serializer);
var projectReferenceChecksums = ChecksumCache.GetOrCreate <ProjectReferenceChecksumCollection>(ProjectReferences, _ => new ProjectReferenceChecksumCollection(ProjectReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var metadataReferenceChecksums = ChecksumCache.GetOrCreate <MetadataReferenceChecksumCollection>(MetadataReferences, _ => new MetadataReferenceChecksumCollection(MetadataReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var analyzerReferenceChecksums = ChecksumCache.GetOrCreate <AnalyzerReferenceChecksumCollection>(AnalyzerReferences, _ => new AnalyzerReferenceChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var documentChecksums = await Task.WhenAll(documentChecksumsTasks).ConfigureAwait(false);
var additionalChecksums = await Task.WhenAll(additionalDocumentChecksumTasks).ConfigureAwait(false);
var analyzerConfigDocumentChecksums = await Task.WhenAll(analyzerConfigDocumentChecksumTasks).ConfigureAwait(false);
return(new ProjectStateChecksums(
infoChecksum,
compilationOptionsChecksum,
parseOptionsChecksum,
new DocumentChecksumCollection(documentChecksums),
projectReferenceChecksums,
metadataReferenceChecksums,
analyzerReferenceChecksums,
new TextDocumentChecksumCollection(additionalChecksums),
new AnalyzerConfigDocumentChecksumCollection(analyzerConfigDocumentChecksums)));
}
}
catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
/// <param name="projectsToInclude">Cone of projects to compute a checksum for. Pass in <see langword="null"/>
/// to get a checksum for the entire solution</param>
private async Task <SolutionStateChecksums> ComputeChecksumsAsync(
HashSet <ProjectId>?projectsToInclude,
SerializableOptionSet options,
CancellationToken cancellationToken)
{
try
{
using (Logger.LogBlock(FunctionId.SolutionState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// get states by id order to have deterministic checksum. Limit to the requested set of projects
// if applicable.
var orderedProjectIds = ChecksumCache.GetOrCreate(ProjectIds, _ => ProjectIds.OrderBy(id => id.Id).ToImmutableArray());
var projectChecksumTasks = orderedProjectIds.Where(id => projectsToInclude == null || projectsToInclude.Contains(id))
.Select(id => ProjectStates[id])
.Where(s => RemoteSupportedLanguages.IsSupported(s.Language))
.Select(s => s.GetChecksumAsync(cancellationToken))
.ToArray();
var serializer = _solutionServices.Workspace.Services.GetRequiredService <ISerializerService>();
var attributesChecksum = serializer.CreateChecksum(SolutionAttributes, cancellationToken);
var optionsChecksum = serializer.CreateChecksum(options, cancellationToken);
var frozenSourceGeneratedDocumentIdentityChecksum = Checksum.Null;
var frozenSourceGeneratedDocumentTextChecksum = Checksum.Null;
if (FrozenSourceGeneratedDocumentState != null)
{
frozenSourceGeneratedDocumentIdentityChecksum = serializer.CreateChecksum(FrozenSourceGeneratedDocumentState.Identity, cancellationToken);
frozenSourceGeneratedDocumentTextChecksum = (await FrozenSourceGeneratedDocumentState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false)).Text;
}
var analyzerReferenceChecksums = ChecksumCache.GetOrCreate <ChecksumCollection>(AnalyzerReferences,
_ => new ChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var projectChecksums = await Task.WhenAll(projectChecksumTasks).ConfigureAwait(false);
return(new SolutionStateChecksums(attributesChecksum, optionsChecksum, new ChecksumCollection(projectChecksums), analyzerReferenceChecksums, frozenSourceGeneratedDocumentIdentityChecksum, frozenSourceGeneratedDocumentTextChecksum));
}
}
catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
{
throw ExceptionUtilities.Unreachable;
}
}
private async Task <SolutionStateChecksums> ComputeChecksumsAsync(CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.SolutionState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// get states by id order to have deterministic checksum
var orderedProjectIds = ChecksumCache.GetOrCreate(ProjectIds, _ => ProjectIds.OrderBy(id => id.Id).ToImmutableArray());
var projectChecksumTasks = orderedProjectIds.Select(id => ProjectStates[id])
.Where(s => RemoteSupportedLanguages.IsSupported(s.Language))
.Select(s => s.GetChecksumAsync(cancellationToken));
var serializer = _solutionServices.Workspace.Services.GetService <ISerializerService>();
var infoChecksum = serializer.CreateChecksum(SolutionAttributes, cancellationToken);
var projectChecksums = await Task.WhenAll(projectChecksumTasks).ConfigureAwait(false);
return(new SolutionStateChecksums(infoChecksum, new ProjectChecksumCollection(projectChecksums)));
}
}
public static async Task <Checksum> GetChecksumAsync(
Document document, CancellationToken cancellationToken)
{
// Since we build the SyntaxTreeIndex from a SyntaxTree, we need our checksum to change
// any time the SyntaxTree could have changed. Right now, that can only happen if the
// text of the document changes, or the ParseOptions change. So we get the checksums
// for both of those, and merge them together to make the final checksum.
var documentChecksumState = await document.State.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
var textChecksum = documentChecksumState.Text;
var parseOptions = document.Project.ParseOptions;
var serializer = new Serializer(document.Project.Solution.Workspace);
var parseOptionsChecksum = ChecksumCache.GetOrCreate(
parseOptions, _ => serializer.CreateChecksum(parseOptions, cancellationToken));
return(Checksum.Create(WellKnownSynchronizationKind.SyntaxTreeIndex, new[] { textChecksum, parseOptionsChecksum }));
}
/// <param name="projectsToInclude">Cone of projects to compute a checksum for. Pass in <see langword="null"/>
/// to get a checksum for the entire solution</param>
private async Task <SolutionStateChecksums> ComputeChecksumsAsync(
HashSet <ProjectId>?projectsToInclude,
SerializableOptionSet options,
CancellationToken cancellationToken)
{
try
{
using (Logger.LogBlock(FunctionId.SolutionState_ComputeChecksumsAsync, FilePath, cancellationToken))
{
// get states by id order to have deterministic checksum. Limit expensive computation to the
// requested set of projects if applicable.
var orderedProjectIds = ChecksumCache.GetOrCreate(ProjectIds, _ => ProjectIds.OrderBy(id => id.Id).ToImmutableArray());
var projectChecksumTasks = orderedProjectIds
.Select(id => (state: ProjectStates[id], mustCompute: projectsToInclude == null || projectsToInclude.Contains(id)))
.Where(t => RemoteSupportedLanguages.IsSupported(t.state.Language))
.Select(async t =>
{
// if it's a project that's specifically in the sync'ed cone, include this checksum so that
// this project definitely syncs over.
if (t.mustCompute)
{
return(await t.state.GetChecksumAsync(cancellationToken).ConfigureAwait(false));
}
// If it's a project that is not in the cone, still try to get the latest checksum for it if
// we have it. That way we don't send over a checksum *without* that project, causing the
// OOP side to throw that project away (along with all the compilation info stored with it).
if (t.state.TryGetStateChecksums(out var stateChecksums))
{
return(stateChecksums.Checksum);
}
// We have never computed the checksum for this project. Don't send anything for it.
return(null);
})
.ToArray();
var serializer = _solutionServices.Workspace.Services.GetRequiredService <ISerializerService>();
var attributesChecksum = serializer.CreateChecksum(SolutionAttributes, cancellationToken);
var optionsChecksum = serializer.CreateChecksum(options, cancellationToken);
var frozenSourceGeneratedDocumentIdentityChecksum = Checksum.Null;
var frozenSourceGeneratedDocumentTextChecksum = Checksum.Null;
if (FrozenSourceGeneratedDocumentState != null)
{
frozenSourceGeneratedDocumentIdentityChecksum = serializer.CreateChecksum(FrozenSourceGeneratedDocumentState.Identity, cancellationToken);
frozenSourceGeneratedDocumentTextChecksum = (await FrozenSourceGeneratedDocumentState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false)).Text;
}
var analyzerReferenceChecksums = ChecksumCache.GetOrCreate <ChecksumCollection>(AnalyzerReferences,
_ => new ChecksumCollection(AnalyzerReferences.Select(r => serializer.CreateChecksum(r, cancellationToken)).ToArray()));
var projectChecksums = await Task.WhenAll(projectChecksumTasks).ConfigureAwait(false);
return(new SolutionStateChecksums(
attributesChecksum,
optionsChecksum,
new ChecksumCollection(projectChecksums.WhereNotNull().ToArray()),
analyzerReferenceChecksums,
frozenSourceGeneratedDocumentIdentityChecksum,
frozenSourceGeneratedDocumentTextChecksum));
}
}
catch (Exception e) when(FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
{
throw ExceptionUtilities.Unreachable;
}
}
