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); }