internal static void VerifyChecksumInService(ISolutionSynchronizationService snapshotService, Checksum checksum, string kind)
{
Assert.NotNull(checksum);
var otherObject = snapshotService.GetRemotableData(checksum, CancellationToken.None);
ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind);
}
internal static void ProjectStateEqual(ISolutionSynchronizationService service, ProjectStateChecksums projectObjects1, ProjectStateChecksums projectObjects2)
{
ChecksumWithChildrenEqual(projectObjects1, projectObjects2);
ChecksumWithChildrenEqual(projectObjects1.Documents.ToDocumentObjects(service), projectObjects2.Documents.ToDocumentObjects(service));
ChecksumWithChildrenEqual(projectObjects1.AdditionalDocuments.ToDocumentObjects(service), projectObjects2.AdditionalDocuments.ToDocumentObjects(service));
}
private ImmutableArray <Checksum> GetHostAnalyzerReferences(
ISolutionSynchronizationService snapshotService, string language, IEnumerable <AnalyzerReference> references, CancellationToken cancellationToken)
{
if (references == null)
{
return(ImmutableArray <Checksum> .Empty);
}
// TODO: cache this to somewhere
var builder = ImmutableArray.CreateBuilder <Checksum>();
foreach (var reference in references)
{
var analyzers = reference.GetAnalyzers(language);
if (analyzers.Length == 0)
{
// skip reference that doesn't contain any analyzers for the given language
// we do this so that we don't load analyzer dlls that MEF exported from vsix
// not related to this solution
continue;
}
var asset = snapshotService.GetGlobalAsset(reference, cancellationToken);
builder.Add(asset.Checksum);
}
return(builder.ToImmutable());
}
internal static async Task VerifySolutionStateSerializationAsync(ISolutionSynchronizationService service, Solution solution, Checksum solutionChecksum)
{
var solutionObjectFromSyncObject = await service.GetValueAsync <SolutionStateChecksums>(solutionChecksum);
Assert.True(solution.State.TryGetStateChecksums(out var solutionObjectFromSolution));
SolutionStateEqual(service, solutionObjectFromSolution, solutionObjectFromSyncObject);
}
internal static void VerifyCollectionInService(ISolutionSynchronizationService snapshotService, ChecksumCollection checksums, int expectedCount, string expectedItemKind)
{
VerifyChecksumInService(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind());
Assert.Equal(checksums.Count, expectedCount);
foreach (var checksum in checksums)
{
VerifyChecksumInService(snapshotService, checksum, expectedItemKind);
}
}
internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, DocumentStateChecksums documentObject)
{
var info = await VerifyAssetSerializationAsync <DocumentInfo.DocumentAttributes>(
service, documentObject.Info, WellKnownSynchronizationKinds.DocumentAttributes,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
await VerifyAssetSerializationAsync <SourceText>(
service, documentObject.Text, WellKnownSynchronizationKinds.SourceText,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
}
internal static void VerifyCollectionInService(ISolutionSynchronizationService snapshotService, ChecksumObjectCollection <DocumentStateChecksums> documents, int expectedCount)
{
VerifySynchronizationObjectInService(snapshotService, documents);
Assert.Equal(documents.Count, expectedCount);
foreach (var documentId in documents)
{
VerifySnapshotInService(snapshotService, documentId);
}
}
internal static void ProjectStatesEqual(ISolutionSynchronizationService service, ChecksumObjectCollection <ProjectStateChecksums> projectObjects1, ChecksumObjectCollection <ProjectStateChecksums> projectObjects2)
{
SynchronizationObjectEqual(projectObjects1, projectObjects2);
Assert.Equal(projectObjects1.Count, projectObjects2.Count);
for (var i = 0; i < projectObjects1.Count; i++)
{
ProjectStateEqual(service, projectObjects1[i], projectObjects2[i]);
}
}
internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, SolutionStateChecksums solutionObject)
{
await VerifyAssetSerializationAsync <SolutionInfo.SolutionAttributes>(
service, solutionObject.Info, WellKnownSynchronizationKinds.SolutionAttributes,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
foreach (var projectChecksum in solutionObject.Projects)
{
var projectObject = await service.GetValueAsync <ProjectStateChecksums>(projectChecksum).ConfigureAwait(false);
await VerifyAssetAsync(service, projectObject).ConfigureAwait(false);
}
}
private ImmutableArray <byte[]> GetHostAnalyzerReferences(ISolutionSynchronizationService snapshotService, IEnumerable <AnalyzerReference> references, CancellationToken cancellationToken)
{
// TODO: cache this to somewhere
var builder = ImmutableArray.CreateBuilder <byte[]>();
foreach (var reference in references)
{
var asset = snapshotService.GetGlobalAsset(reference, cancellationToken);
builder.Add(asset.Checksum.ToArray());
}
return(builder.ToImmutable());
}
internal static async Task VerifyAssetAsync(ISolutionSynchronizationService service, ProjectStateChecksums projectObject)
{
var info = await VerifyAssetSerializationAsync <ProjectInfo.ProjectAttributes>(
service, projectObject.Info, WellKnownSynchronizationKinds.ProjectAttributes,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
await VerifyAssetSerializationAsync <CompilationOptions>(
service, projectObject.CompilationOptions, WellKnownSynchronizationKinds.CompilationOptions,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
await VerifyAssetSerializationAsync <ParseOptions>(
service, projectObject.ParseOptions, WellKnownSynchronizationKinds.ParseOptions,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
foreach (var checksum in projectObject.Documents)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
foreach (var checksum in projectObject.ProjectReferences)
{
await VerifyAssetSerializationAsync <ProjectReference>(
service, checksum, WellKnownSynchronizationKinds.ProjectReference,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.MetadataReferences)
{
await VerifyAssetSerializationAsync <MetadataReference>(
service, checksum, WellKnownSynchronizationKinds.MetadataReference,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.AnalyzerReferences)
{
await VerifyAssetSerializationAsync <AnalyzerReference>(
service, checksum, WellKnownSynchronizationKinds.AnalyzerReference,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.AdditionalDocuments)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
}
internal static async Task <T> VerifyAssetSerializationAsync <T>(
ISolutionSynchronizationService service,
Checksum checksum,
string kind,
Func <T, string, Serializer, RemotableData> assetGetter)
{
// re-create asset from object
var syncService = (SolutionSynchronizationServiceFactory.Service)service;
var syncObject = service.GetRemotableData(checksum, CancellationToken.None);
var recoveredValue = await service.GetValueAsync <T>(checksum);
var recreatedSyncObject = assetGetter(recoveredValue, kind, syncService.Serializer_TestOnly);
// make sure original object and re-created object are same.
SynchronizationObjectEqual(syncObject, recreatedSyncObject);
return(recoveredValue);
}
public static async Task <T> GetValueAsync <T>(this ISolutionSynchronizationService service, Checksum checksum)
{
var syncService = (SolutionSynchronizationServiceFactory.Service)service;
var syncObject = service.GetRemotableData(checksum, CancellationToken.None);
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new StreamObjectWriter(stream))
{
// serialize asset to bits
await syncObject.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
stream.Position = 0;
using (var reader = new StreamObjectReader(stream))
{
// deserialize bits to object
var serializer = syncService.Serializer_TestOnly;
return(serializer.Deserialize <T>(syncObject.Kind, reader, CancellationToken.None));
}
}
}
internal static void VerifySnapshotInService(
ISolutionSynchronizationService snapshotService,
ProjectStateChecksums projectObject,
int expectedDocumentCount,
int expectedProjectReferenceCount,
int expectedMetadataReferenceCount,
int expectedAnalyzerReferenceCount,
int expectedAdditionalDocumentCount)
{
VerifyChecksumInService(snapshotService, projectObject.Checksum, projectObject.GetWellKnownSynchronizationKind());
VerifyChecksumInService(snapshotService, projectObject.Info, WellKnownSynchronizationKinds.ProjectAttributes);
VerifyChecksumInService(snapshotService, projectObject.CompilationOptions, WellKnownSynchronizationKinds.CompilationOptions);
VerifyChecksumInService(snapshotService, projectObject.ParseOptions, WellKnownSynchronizationKinds.ParseOptions);
VerifyCollectionInService(snapshotService, projectObject.Documents.ToDocumentObjects(snapshotService), expectedDocumentCount);
VerifyCollectionInService(snapshotService, projectObject.ProjectReferences, expectedProjectReferenceCount, WellKnownSynchronizationKinds.ProjectReference);
VerifyCollectionInService(snapshotService, projectObject.MetadataReferences, expectedMetadataReferenceCount, WellKnownSynchronizationKinds.MetadataReference);
VerifyCollectionInService(snapshotService, projectObject.AnalyzerReferences, expectedAnalyzerReferenceCount, WellKnownSynchronizationKinds.AnalyzerReference);
VerifyCollectionInService(snapshotService, projectObject.AdditionalDocuments.ToDocumentObjects(snapshotService), expectedAdditionalDocumentCount);
}
private async Task <Solution> GetSolutionAsync(ISolutionSynchronizationService service, PinnedRemotableDataScope syncScope)
{
var workspace = new AdhocWorkspace();
var solutionObject = await service.GetValueAsync <SolutionStateChecksums>(syncScope.SolutionChecksum);
var solutionInfo = await service.GetValueAsync <SolutionInfo.SolutionAttributes>(solutionObject.Info).ConfigureAwait(false);
var projects = new List <ProjectInfo>();
foreach (var projectObject in solutionObject.Projects.ToProjectObjects(service))
{
var projectInfo = await service.GetValueAsync <ProjectInfo.ProjectAttributes>(projectObject.Info).ConfigureAwait(false);
if (!workspace.Services.IsSupported(projectInfo.Language))
{
continue;
}
var documents = new List <DocumentInfo>();
foreach (var documentObject in projectObject.Documents.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync <DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync <SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
documents.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var p2p = new List <ProjectReference>();
foreach (var checksum in projectObject.ProjectReferences)
{
var reference = await service.GetValueAsync <ProjectReference>(checksum).ConfigureAwait(false);
p2p.Add(reference);
}
var metadata = new List <MetadataReference>();
foreach (var checksum in projectObject.MetadataReferences)
{
var reference = await service.GetValueAsync <MetadataReference>(checksum).ConfigureAwait(false);
metadata.Add(reference);
}
var analyzers = new List <AnalyzerReference>();
foreach (var checksum in projectObject.AnalyzerReferences)
{
var reference = await service.GetValueAsync <AnalyzerReference>(checksum).ConfigureAwait(false);
analyzers.Add(reference);
}
var additionals = new List <DocumentInfo>();
foreach (var documentObject in projectObject.AdditionalDocuments.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync <DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync <SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
additionals.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var compilationOptions = await service.GetValueAsync <CompilationOptions>(projectObject.CompilationOptions).ConfigureAwait(false);
var parseOptions = await service.GetValueAsync <ParseOptions>(projectObject.ParseOptions).ConfigureAwait(false);
projects.Add(
ProjectInfo.Create(
projectInfo.Id, projectInfo.Version, projectInfo.Name, projectInfo.AssemblyName,
projectInfo.Language, projectInfo.FilePath, projectInfo.OutputFilePath,
compilationOptions, parseOptions,
documents, p2p, metadata, analyzers, additionals, projectInfo.IsSubmission));
}
return(workspace.AddSolution(SolutionInfo.Create(solutionInfo.Id, solutionInfo.Version, solutionInfo.FilePath, projects)));
}
private ImmutableArray<byte[]> GetHostAnalyzerReferences(
ISolutionSynchronizationService snapshotService, string language, IEnumerable<AnalyzerReference> references, CancellationToken cancellationToken)
{
// TODO: cache this to somewhere
var builder = ImmutableArray.CreateBuilder<byte[]>();
foreach (var reference in references)
{
var analyzers = reference.GetAnalyzers(language);
if (analyzers.Length == 0)
{
// skip reference that doesn't contain any analyzers for the given language
// we do this so that we don't load analyzer dlls that MEF exported from vsix
// not related to this solution
continue;
}
var asset = snapshotService.GetGlobalAsset(reference, cancellationToken);
builder.Add(asset.Checksum.ToArray());
}
return builder.ToImmutable();
}
private async Task<Solution> GetSolutionAsync(ISolutionSynchronizationService service, PinnedRemotableDataScope syncScope)
{
var workspace = new AdhocWorkspace();
var solutionObject = await service.GetValueAsync<SolutionStateChecksums>(syncScope.SolutionChecksum);
var solutionInfo = await service.GetValueAsync<SolutionInfo.SolutionAttributes>(solutionObject.Info).ConfigureAwait(false);
var projects = new List<ProjectInfo>();
foreach (var projectObject in solutionObject.Projects.ToProjectObjects(service))
{
var projectInfo = await service.GetValueAsync<ProjectInfo.ProjectAttributes>(projectObject.Info).ConfigureAwait(false);
if (!workspace.Services.IsSupported(projectInfo.Language))
{
continue;
}
var documents = new List<DocumentInfo>();
foreach (var documentObject in projectObject.Documents.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync<DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync<SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
documents.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var p2p = new List<ProjectReference>();
foreach (var checksum in projectObject.ProjectReferences)
{
var reference = await service.GetValueAsync<ProjectReference>(checksum).ConfigureAwait(false);
p2p.Add(reference);
}
var metadata = new List<MetadataReference>();
foreach (var checksum in projectObject.MetadataReferences)
{
var reference = await service.GetValueAsync<MetadataReference>(checksum).ConfigureAwait(false);
metadata.Add(reference);
}
var analyzers = new List<AnalyzerReference>();
foreach (var checksum in projectObject.AnalyzerReferences)
{
var reference = await service.GetValueAsync<AnalyzerReference>(checksum).ConfigureAwait(false);
analyzers.Add(reference);
}
var additionals = new List<DocumentInfo>();
foreach (var documentObject in projectObject.AdditionalDocuments.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync<DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync<SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
additionals.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var compilationOptions = await service.GetValueAsync<CompilationOptions>(projectObject.CompilationOptions).ConfigureAwait(false);
var parseOptions = await service.GetValueAsync<ParseOptions>(projectObject.ParseOptions).ConfigureAwait(false);
projects.Add(
ProjectInfo.Create(
projectInfo.Id, projectInfo.Version, projectInfo.Name, projectInfo.AssemblyName,
projectInfo.Language, projectInfo.FilePath, projectInfo.OutputFilePath,
compilationOptions, parseOptions,
documents, p2p, metadata, analyzers, additionals, projectInfo.IsSubmission));
}
return workspace.AddSolution(SolutionInfo.Create(solutionInfo.Id, solutionInfo.Version, solutionInfo.FilePath, projects));
}
internal static void SolutionStateEqual(ISolutionSynchronizationService service, SolutionStateChecksums solutionObject1, SolutionStateChecksums solutionObject2)
{
ChecksumWithChildrenEqual(solutionObject1, solutionObject2);
ProjectStatesEqual(service, solutionObject1.Projects.ToProjectObjects(service), solutionObject2.Projects.ToProjectObjects(service));
}
public static ChecksumObjectCollection <DocumentStateChecksums> ToDocumentObjects(this TextDocumentChecksumCollection collection, ISolutionSynchronizationService service)
{
return(new ChecksumObjectCollection <DocumentStateChecksums>(service, collection));
}
public static ChecksumObjectCollection <ProjectStateChecksums> ToProjectObjects(this ProjectChecksumCollection collection, ISolutionSynchronizationService service)
{
return(new ChecksumObjectCollection <ProjectStateChecksums>(service, collection));
}
internal static void VerifySnapshotInService(ISolutionSynchronizationService snapshotService, DocumentStateChecksums documentObject)
{
VerifyChecksumInService(snapshotService, documentObject.Checksum, documentObject.GetWellKnownSynchronizationKind());
VerifyChecksumInService(snapshotService, documentObject.Info, WellKnownSynchronizationKinds.DocumentAttributes);
VerifyChecksumInService(snapshotService, documentObject.Text, WellKnownSynchronizationKinds.SourceText);
}
public ChecksumObjectCollection(ISolutionSynchronizationService service, ChecksumCollection collection) : base(collection.Checksum, collection.GetWellKnownSynchronizationKind())
{
// using .Result here since we don't want to convert all calls to this to async.
// and none of ChecksumWithChildren actually use async
Children = ImmutableArray.CreateRange(collection.Select(c => service.GetValueAsync <T>(c).Result));
}
internal static void VerifySynchronizationObjectInService <T>(ISolutionSynchronizationService snapshotService, T syncObject) where T : RemotableData
{
VerifyChecksumInService(snapshotService, syncObject.Checksum, syncObject.Kind);
}
