public static ValueTask <ImmutableArray <ISymbol> > FindBasesAsync( ISymbol symbol, Solution solution, CancellationToken cancellationToken ) { if ( symbol is INamedTypeSymbol namedTypeSymbol && ( namedTypeSymbol.TypeKind == TypeKind.Class || namedTypeSymbol.TypeKind == TypeKind.Interface || namedTypeSymbol.TypeKind == TypeKind.Struct ) ) { return(ValueTaskFactory.FromResult( BaseTypeFinder.FindBaseTypesAndInterfaces(namedTypeSymbol) )); } if ( symbol.Kind == SymbolKind.Property || symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.Event ) { return(BaseTypeFinder.FindOverriddenAndImplementedMembersAsync( symbol, solution, cancellationToken )); } return(ValueTaskFactory.FromResult(ImmutableArray <ISymbol> .Empty)); }
public override ValueTask <Stream?> SerializeAsync( object?message, MessageHeaderCollection messageHeaders, MessageSerializationContext context) { Check.NotNull(messageHeaders, nameof(messageHeaders)); if (message == null) { return(ValueTaskFactory.FromResult <Stream?>(null)); } if (message is Stream inputStream) { return(ValueTaskFactory.FromResult <Stream?>(inputStream)); } if (message is byte[] inputBytes) { return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes))); } var type = message.GetType(); messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName); var bytes = JsonSerializer.SerializeToUtf8Bytes(message, type, Options); return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes))); }
public async Task TestFailedInstallRollsBackFile() { var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict); installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true); installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false); installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "1.0")).Returns(ImmutableArray <Project> .Empty); installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources); installerServiceMock.Setup(s => s.GetInstalledVersions("NuGetPackage")) .Returns(ImmutableArray.Create("1.0")); installerServiceMock.Setup(s => s.TryInstallPackage(It.IsAny <Workspace>(), It.IsAny <DocumentId>(), It.IsAny <string>(), "NuGetPackage", "1.0", It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Returns(false); var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict); packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty)); packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync(NugetOrgSource, "NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NuGetNamespace"))); await TestInRegularAndScriptAsync( @"class C { [|NuGetType|] n; }", @"class C { NuGetType n; }", fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object)); installerServiceMock.Verify(); }
private async Task <RemoteHostClient?> CreateHostClientAsync() { try { var brokeredServiceContainer = await _vsServiceProvider .GetServiceAsync <SVsBrokeredServiceContainer, IBrokeredServiceContainer>() .ConfigureAwait(false); var serviceBroker = brokeredServiceContainer.GetFullAccessServiceBroker(); // VS AsyncLazy does not currently support cancellation: var client = await ServiceHubRemoteHostClient .CreateAsync( _services, _listenerProvider, serviceBroker, _callbackDispatchers, CancellationToken.None ) .ConfigureAwait(false); // proffer in-proc brokered services: _ = brokeredServiceContainer.Proffer( SolutionAssetProvider.ServiceDescriptor, (_, _, _, _) => ValueTaskFactory.FromResult <object?>(new SolutionAssetProvider(_services)) ); return(client); } catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e)) { return(null); } }
public async Task TestSearchPackageSingleName() { var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict); installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true); installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false); installerServiceMock.Setup(i => i.GetInstalledVersions("NuGetPackage")).Returns(ImmutableArray <string> .Empty); installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources); installerServiceMock.Setup(s => s.TryInstallPackageAsync(It.IsAny <Workspace>(), It.IsAny <DocumentId>(), It.IsAny <string>(), "NuGetPackage", It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <IProgressTracker>(), It.IsAny <CancellationToken>())) .Returns(SpecializedTasks.True); var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict); packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty)); packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync( PackageSourceHelper.NugetOrgSourceName, "NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NuGetNamespace"))); await TestInRegularAndScriptAsync( @"class C { [|NuGetType|] n; }", @"using NuGetNamespace; class C { NuGetType n; }", fixProviderData : new FixProviderData(installerServiceMock.Object, packageServiceMock.Object)); }
public override ValueTask <Stream?> SerializeAsync( object?message, MessageHeaderCollection messageHeaders, MessageSerializationContext context) { Check.NotNull(messageHeaders, nameof(messageHeaders)); if (message == null) { return(ValueTaskFactory.FromResult <Stream?>(null)); } if (message is Stream inputStream) { return(ValueTaskFactory.FromResult <Stream?>(inputStream)); } if (message is byte[] inputBytes) { return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes))); } var type = message.GetType(); var jsonString = JsonConvert.SerializeObject(message, type, Settings); messageHeaders.AddOrReplace(DefaultMessageHeaders.MessageType, type.AssemblyQualifiedName); return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString)))); }
public ValueTask <T?> GetProxyAsync <T>(ServiceRpcDescriptor descriptor, ServiceActivationOptions options, CancellationToken cancellationToken) where T : class { var pipePair = FullDuplexStream.CreatePipePair(); var clientConnection = descriptor .WithTraceSource(_services.ServiceProvider.TraceSource) .ConstructRpcConnection(pipePair.Item2); Contract.ThrowIfFalse(options.ClientRpcTarget is null == descriptor.ClientInterface is null); if (descriptor.ClientInterface != null) { Contract.ThrowIfNull(options.ClientRpcTarget); clientConnection.AddLocalRpcTarget(options.ClientRpcTarget); } // Clear RPC target so that the server connection is forced to create a new proxy for the callback // instead of just invoking the callback object directly (this emulates the product that does // not serialize the callback object over). options.ClientRpcTarget = null; // Creates service instance and connects it to the pipe. // We don't need to store the instance anywhere. _ = _services.CreateBrokeredService(descriptor, pipePair.Item1, options); clientConnection.StartListening(); return(ValueTaskFactory.FromResult((T?)clientConnection.ConstructRpcClient <T>())); }
public ValueTask <ImmutableArray <(Checksum, object)> > GetAssetsAsync( int serviceId, ISet <Checksum> checksums, ISerializerService deserializerService, CancellationToken cancellationToken) { var results = new List <(Checksum, object)>(); foreach (var checksum in checksums) { if (_map.TryGetValue(checksum, out var data)) { using var stream = new MemoryStream(); using var context = SolutionReplicationContext.Create(); using (var writer = new ObjectWriter(stream, leaveOpen: true, cancellationToken)) { _serializerService.Serialize(data, writer, context, cancellationToken); } stream.Position = 0; using var reader = ObjectReader.GetReader(stream, leaveOpen: true, cancellationToken); var asset = deserializerService.Deserialize <object>(data.GetWellKnownSynchronizationKind(), reader, cancellationToken); Contract.ThrowIfTrue(asset is null); results.Add((checksum, asset)); } else { throw ExceptionUtilities.UnexpectedValue(checksum); } } return(ValueTaskFactory.FromResult(results.ToImmutableArray())); }
public void WhenAll_AllCompletedSuccessfully() { var whenAll = SpecializedTasks.WhenAll(new[] { ValueTaskFactory.FromResult(0), ValueTaskFactory.FromResult(1) }); Debug.Assert(whenAll.IsCompleted); Assert.True(whenAll.IsCompletedSuccessfully); Assert.Equal(new[] { 0, 1 }, whenAll.Result); }
ValueTask <CodeAndImportGenerationOptions> OptionsProvider <CodeAndImportGenerationOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken) { var codeActionOptions = GetOptions(languageServices); return(ValueTaskFactory.FromResult(new CodeAndImportGenerationOptions( codeActionOptions.CodeGenerationOptions ?? CodeGenerationOptions.GetDefault(languageServices), codeActionOptions.CleanupOptions?.AddImportOptions ?? AddImportPlacementOptions.Default))); }
public void FromResult_IntResult_SuccessfulTaskCreated() { var result = ValueTaskFactory.FromResult(42); result.IsCompleted.Should().BeTrue(); result.IsCompletedSuccessfully.Should().BeTrue(); result.Result.Should().Be(42); }
/// <nodoc/> public ValueTask <Possible <IReadOnlyCollection <ModuleDescriptor> > > TryGetModuleDescriptorsAsync(ModuleReferenceWithProvenance moduleReference) { return (ValueTaskFactory.FromResult( new Possible <IReadOnlyCollection <ModuleDescriptor> >( m_moduleDefinitions.Keys.Where(moduleDescriptor => moduleDescriptor.Name.Equals(moduleReference.Name)) .ToList()))); }
public static ValueTask <OptionSet?> GetDocumentOptionSetAsync(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken) { if (analyzerOptions is not WorkspaceAnalyzerOptions workspaceAnalyzerOptions) { return(ValueTaskFactory.FromResult((OptionSet?)null)); } return(workspaceAnalyzerOptions.GetDocumentOptionSetAsync(syntaxTree, cancellationToken)); }
public async Task TestMissingIfPackageAlreadyInstalled() { var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict); installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true); installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources); installerServiceMock .Setup( s => s.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage") ) .Returns(true); var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict); packageServiceMock .Setup( s => s.FindReferenceAssembliesWithTypeAsync( "NuGetType", 0, It.IsAny <CancellationToken>() ) ) .Returns( ValueTaskFactory.FromResult( ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty ) ); packageServiceMock .Setup( s => s.FindPackagesWithTypeAsync( NugetOrgSource, "NuGetType", 0, It.IsAny <CancellationToken>() ) ) .Returns( CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NS1", "NS2")) ); await TestMissingInRegularAndScriptAsync( @"class C { [|NuGetType|] n; }", new TestParameters( fixProviderData : new FixProviderData( installerServiceMock.Object, packageServiceMock.Object ) ) ); }
private ValueTask <ImmutableArray <DiagnosticData> > DeserializeDiagnosticsAsync(IPersistentStorageService persistentService, DiagnosticDataSerializer serializer, Project project, TextDocument?document, object key, string stateKey, CancellationToken cancellationToken) { Contract.ThrowIfFalse(document == null || document.Project == project); if (InMemoryStorage.TryGetValue(_owner.Analyzer, (key, stateKey), out var entry) && serializer.Version == entry.Version) { return(ValueTaskFactory.FromResult(entry.Diagnostics)); } return(serializer.DeserializeAsync(persistentService, project, document, stateKey, cancellationToken)); }
private static ValueTask <ImmutableArray <INavigateToSearchResult> > RehydrateAsync( Optional <ImmutableArray <SerializableNavigateToSearchResult> > result, Solution solution, CancellationToken cancellationToken) { if (result.HasValue) { return(result.Value.SelectAsArrayAsync(r => r.RehydrateAsync(solution, cancellationToken))); } else { return(ValueTaskFactory.FromResult(ImmutableArray <INavigateToSearchResult> .Empty)); } }
public async ValueTask <Solution> GetSolutionAsync(ServiceBrokerClient client, Checksum solutionChecksum, CancellationToken cancellationToken) { var assetSource = new SolutionAssetSource(client); var workspace = GetWorkspace(); var assetProvider = workspace.CreateAssetProvider(solutionChecksum, SolutionAssetCache, assetSource); var(solution, _) = await workspace.RunWithSolutionAsync( assetProvider, solutionChecksum, static _ => ValueTaskFactory.FromResult(false), cancellationToken).ConfigureAwait(false); return(solution); }
/// <nodoc/> public ValueTask <Possible <ModuleDescriptor> > TryGetOwningModuleDescriptorAsync(AbsolutePath specPath) { foreach (var moduleDefinition in m_moduleDefinitions.Values) { if (moduleDefinition.Specs.Contains(specPath)) { return(ValueTaskFactory.FromResult(new Possible <ModuleDescriptor>(moduleDefinition.Descriptor))); } } return (ValueTaskFactory.FromResult( new Possible <ModuleDescriptor>(new ModuleNotFoundInSimpleSourceResolverFailure(specPath)))); }
public ValueTask <ManagedHotReloadAvailability> GetAvailabilityAsync(Guid mvid, CancellationToken cancellationToken) { if (IsEditAndContinueAvailable != null) { return(ValueTaskFactory.FromResult(IsEditAndContinueAvailable(mvid))); } if (LoadedModules != null) { return(ValueTaskFactory.FromResult(LoadedModules.TryGetValue(mvid, out var result) ? result : new ManagedHotReloadAvailability(ManagedHotReloadAvailabilityStatus.ModuleNotLoaded))); } throw new NotImplementedException(); }
public async Task TestOptionsOffered() { var installerServiceMock = new Mock <IPackageInstallerService>(MockBehavior.Strict); installerServiceMock.Setup(i => i.IsEnabled(It.IsAny <ProjectId>())).Returns(true); installerServiceMock.Setup(i => i.IsInstalled(It.IsAny <Workspace>(), It.IsAny <ProjectId>(), "NuGetPackage")).Returns(false); installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "1.0")).Returns(ImmutableArray <Project> .Empty); installerServiceMock.Setup(i => i.GetProjectsWithInstalledPackage(It.IsAny <Solution>(), "NuGetPackage", "2.0")).Returns(ImmutableArray <Project> .Empty); installerServiceMock.Setup(i => i.TryGetPackageSources()).Returns(NugetPackageSources); installerServiceMock.Setup(s => s.GetInstalledVersions("NuGetPackage")) .Returns(ImmutableArray.Create("1.0", "2.0")); var packageServiceMock = new Mock <ISymbolSearchService>(MockBehavior.Strict); packageServiceMock.Setup(s => s.FindReferenceAssembliesWithTypeAsync("NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(() => ValueTaskFactory.FromResult(ImmutableArray <ReferenceAssemblyWithTypeResult> .Empty)); packageServiceMock.Setup(s => s.FindPackagesWithTypeAsync( PackageSourceHelper.NugetOrgSourceName, "NuGetType", 0, It.IsAny <CancellationToken>())) .Returns(() => CreateSearchResult("NuGetPackage", "NuGetType", CreateNameParts("NS1", "NS2"))); var data = new FixProviderData(installerServiceMock.Object, packageServiceMock.Object); await TestSmartTagTextAsync( @"class C { [|NuGetType|] n; }", string.Format(FeaturesResources.Use_local_version_0, "1.0"), parameters : new TestParameters(fixProviderData: data)); await TestSmartTagTextAsync( @"class C { [|NuGetType|] n; }", string.Format(FeaturesResources.Use_local_version_0, "2.0"), parameters : new TestParameters(index: 1, fixProviderData: data)); await TestSmartTagTextAsync( @"class C { [|NuGetType|] n; }", FeaturesResources.Find_and_install_latest_version, parameters : new TestParameters(index: 2, fixProviderData: data)); }
public ValueTask <Stream?> SerializeAsync( object?message, MessageHeaderCollection messageHeaders, MessageSerializationContext context) { Check.NotNull(messageHeaders, nameof(messageHeaders)); if (message == null) { return(ValueTaskFactory.FromResult <Stream?>(null)); } if (message is Stream inputStream) { return(ValueTaskFactory.FromResult <Stream?>(inputStream)); } if (message is byte[] inputBytes) { return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes))); } var binaryFileMessage = message as IBinaryFileMessage; if (binaryFileMessage == null) { throw new ArgumentException( "The message is not implementing the IBinaryFileMessage interface.", nameof(message)); } messageHeaders.AddOrReplace( DefaultMessageHeaders.MessageType, message.GetType().AssemblyQualifiedName); return(ValueTaskFactory.FromResult(binaryFileMessage.Content)); }
public override ValueTask <Stream?> SerializeAsync( object?message, MessageHeaderCollection messageHeaders, MessageSerializationContext context) { if (message == null) { return(ValueTaskFactory.FromResult <Stream?>(null)); } if (message is Stream inputStream) { return(ValueTaskFactory.FromResult <Stream?>(inputStream)); } if (message is byte[] inputBytes) { return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes))); } var bytes = JsonSerializer.SerializeToUtf8Bytes(message, _type, Options); return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(bytes))); }
public override ValueTask <Stream?> SerializeAsync( object?message, MessageHeaderCollection messageHeaders, MessageSerializationContext context) { if (message == null) { return(ValueTaskFactory.FromResult <Stream?>(null)); } if (message is Stream inputStream) { return(ValueTaskFactory.FromResult <Stream?>(inputStream)); } if (message is byte[] inputBytes) { return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(inputBytes))); } var jsonString = JsonConvert.SerializeObject(message, _type, Settings); return(ValueTaskFactory.FromResult <Stream?>(new MemoryStream(GetSystemEncoding().GetBytes(jsonString)))); }
public ValueTask <bool> IsExperimentEnabledAsync(string experimentName, CancellationToken cancellationToken) => ValueTaskFactory.FromResult(false);
protected override ValueTask <ImmutableArray <Document> > GetOrderedDocumentsAsync(RequestContext context, CancellationToken cancellationToken) { return(ValueTaskFactory.FromResult(GetRequestedDocument(context))); }
public static ValueTask <ISymbolSearchUpdateEngine> CreateEngineAsync( Workspace workspace, ISymbolSearchLogService logService, CancellationToken cancellationToken) => ValueTaskFactory.FromResult <ISymbolSearchUpdateEngine>(SymbolSearchUpdateNoOpEngine.Instance);
public ValueTask <bool> IsExperimentEnabledAsync(string experimentName, CancellationToken cancellationToken) => ValueTaskFactory.FromResult(_services.GetRequiredService <IExperimentationService>().IsExperimentEnabled(experimentName));
public ValueTask <ImmutableArray <string> > GetCapabilitiesAsync(CancellationToken cancellationToken) => ValueTaskFactory.FromResult(GetCapabilitiesImpl?.Invoke() ?? ImmutableArray.Create("Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"));
public ValueTask <ImmutableArray <ManagedActiveStatementDebugInfo> > GetActiveStatementsAsync(CancellationToken cancellationToken) => ValueTaskFactory.FromResult(GetActiveStatementsImpl?.Invoke() ?? ImmutableArray <ManagedActiveStatementDebugInfo> .Empty);
public ValueTask <ImmutableArray <string> > GetCapabilitiesAsync(CancellationToken cancellationToken) => ValueTaskFactory.FromResult(_capabilities);