internal static async Task VerifyAssetAsync(IRemotableDataService service, ProjectStateChecksums projectObject)
{
var info = await VerifyAssetSerializationAsync <ProjectInfo.ProjectAttributes>(
service, projectObject.Info, WellKnownSynchronizationKind.ProjectAttributes,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
await VerifyAssetSerializationAsync <CompilationOptions>(
service, projectObject.CompilationOptions, WellKnownSynchronizationKind.CompilationOptions,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
await VerifyAssetSerializationAsync <ParseOptions>(
service, projectObject.ParseOptions, WellKnownSynchronizationKind.ParseOptions,
(v, k, s) => new SolutionAsset(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, WellKnownSynchronizationKind.ProjectReference,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.MetadataReferences)
{
await VerifyAssetSerializationAsync <MetadataReference>(
service, checksum, WellKnownSynchronizationKind.MetadataReference,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.AnalyzerReferences)
{
await VerifyAssetSerializationAsync <AnalyzerReference>(
service, checksum, WellKnownSynchronizationKind.AnalyzerReference,
(v, k, s) => new SolutionAsset(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);
}
foreach (var checksum in projectObject.AnalyzerConfigDocuments)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
}
internal static async Task VerifySolutionStateSerializationAsync(IRemotableDataService 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 async Task VerifyAssetAsync(IRemotableDataService service, SolutionStateChecksums solutionObject)
{
await VerifyAssetSerializationAsync <SolutionInfo.SolutionAttributes>(
service, solutionObject.Info, WellKnownSynchronizationKind.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);
}
}
internal static async Task <T> VerifyAssetSerializationAsync <T>(
IRemotableDataService service,
Checksum checksum,
WellKnownSynchronizationKind kind,
Func <T, WellKnownSynchronizationKind, ISerializerService, RemotableData> assetGetter)
{
// re-create asset from object
var syncService = (RemotableDataServiceFactory.Service)service;
var syncObject = syncService.GetRemotableData_TestOnly(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);
}
private async Task <Solution> GetSolutionAsync(IRemotableDataService 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)));
}
public ChecksumObjectCollection(IRemotableDataService 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));
}
public Task <T> GetAssetAsync <T>(Checksum checksum, CancellationToken cancellationToken)
{
return(_service.GetValueAsync <T>(checksum));
}
public override Task <T> GetAssetAsync <T>(Checksum checksum, CancellationToken cancellationToken) => _service.GetValueAsync <T>(checksum);