1330var references = Task.Run(() => defaultReferences.ResolveAsync(LanguageNames.CSharp, CancellationToken.None)).GetAwaiter().GetResult();

421var cancellationToken = CancellationToken.None;

26_cancellationToken = cancellationToken ?? CancellationToken.None;

53CancellationToken.None 86var exitCode = await runner.BuildAsync(projectFile, options, CancellationToken.None); 128var exitCode = await runner.BuildAsync(projectFile, options, CancellationToken.None); 168CancellationToken.None 212CancellationToken.None 261CancellationToken.None

29await detector.StartAsync(CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5)); 48await detector.StartAsync(CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5)); 74await detector.StartAsync(CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5));

21interactionService.PromptForSelectionAsync("Select an item:", choices, x => x, CancellationToken.None));

39var packages = await nuGetPackageCache.GetCliPackagesAsync(workspace.WorkspaceRoot, prerelease: true, source: null, CancellationToken.None).WaitAsync(CliTestConstants.DefaultTimeout);

297await locator.UseOrFindAppHostProjectFileAsync(null, CancellationToken.None);

140response = await dashboardClient.ExecuteResourceCommandAsync(resource.Name, resource.ResourceType, command, CancellationToken.None).ConfigureAwait(false);

106var browserThemeSettings = await _themeResolver.GetThemeSettingsAsync(CancellationToken.None).ConfigureAwait(false);

51var (_, subscription) = await client.SubscribeResourcesAsync(CancellationToken.None).DefaultTimeout(); 79var (_, subscription) = await client.SubscribeResourcesAsync(CancellationToken.None).DefaultTimeout(); 104await Assert.ThrowsAsync<ObjectDisposedException>(() => client.SubscribeResourcesAsync(CancellationToken.None)).DefaultTimeout(); 117_ = await client.SubscribeResourcesAsync(CancellationToken.None).DefaultTimeout(); 135var subscribeTask = client.SubscribeResourcesAsync(CancellationToken.None); 162var subscription = client.SubscribeInteractionsAsync(CancellationToken.None); 189var subscription = client.SubscribeInteractionsAsync(CancellationToken.None); 214Assert.Throws<ObjectDisposedException>(() => client.SubscribeInteractionsAsync(CancellationToken.None)); 226_ = client.SubscribeInteractionsAsync(CancellationToken.None);

122return GetDashboardUrlsAsync(CancellationToken.None);

348var result = await reader.ReadAsync(CancellationToken.None).ConfigureAwait(false);

108await Task.Delay(1000, CancellationToken.None).ConfigureAwait(false);

154await Reporter.CompleteStepAsync(this, completionText, finalState, CancellationToken.None).ConfigureAwait(false);

86await CompleteAsync(cancellationToken: CancellationToken.None).ConfigureAwait(false);

110var result = await bicepExecutor.CompileBicepToArmAsync("test.bicep", CancellationToken.None); 148var token = credential.GetToken(requestContext, CancellationToken.None); 166var token = await credential.GetTokenAsync(requestContext, CancellationToken.None);

276var cs = await csExpr.GetValueAsync(CancellationToken.None); 297await ExecuteBeforeStartHooksAsync(app, CancellationToken.None); 331await ExecuteBeforeStartHooksAsync(app, CancellationToken.None);

82hb.Configuration["ConnectionStrings:hub"] = await eventHub.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 88hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 134hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 140hb.Configuration["ConnectionStrings:eventhubns"] = await eventHubns.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None) + $";EntityPath={hubName};"; 353var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = eventHubsEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 414var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = eventHubsEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 488var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = eventHubsEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None);

60await ExecuteBeforeStartHooksAsync(app, CancellationToken.None); 132Assert.StartsWith("Host=localhost;Port=12455;Username=postgres;Password=", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None)); 134var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 138var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 190Assert.Equal("Host=localhost;Port=12455;Username=user1;Password=p@ssw0rd1", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None)); 192var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 195var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 229Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1", await postgres.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None)); 230Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1;Database=db1", await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None)); 231Assert.Equal("Host=localhost;Port=12455;Username=user;Password=p@ssw0rd1;Database=db2Name", await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));

59await ExecuteBeforeStartHooksAsync(app, CancellationToken.None); 106Assert.Equal($"localhost:12455,password={redisResource.PasswordParameter.Value}", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None)); 140Assert.Equal($"localhost:12455,password=p@ssw0rd1", await redis.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None));

129hb.Configuration["ConnectionStrings:servicebusns"] = await serviceBus.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 369var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = serviceBusEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 468var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = serviceBusEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 524var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = serviceBusEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 583var configFiles = await configAnnotation.Callback(new ContainerFileSystemCallbackContext { Model = serviceBusEmulatorResource, ServiceProvider = app.Services }, CancellationToken.None); 810hb.Configuration["ConnectionStrings:servicebusns"] = await serviceBus.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);

31var connectionString = await connectionStringExpr.GetValueAsync(CancellationToken.None);

93var serverConnectionString = await sql.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 97var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 101var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 105var db3ConnectionString = await db3.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 159var serverConnectionString = await sql.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 162var db1ConnectionString = await db1.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 165var db2ConnectionString = await db2.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 168var db3ConnectionString = await db3.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);

176hb.Configuration[$"ConnectionStrings:{blobsResourceName}"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 177hb.Configuration[$"ConnectionStrings:{blobContainerName}"] = await container.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 178hb.Configuration[$"ConnectionStrings:{queuesResourceName}"] = await queues.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 179hb.Configuration[$"ConnectionStrings:{queueName}"] = await queue.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 227hb.Configuration["ConnectionStrings:BlobConnection"] = await blobs.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None); 266hb.Configuration["ConnectionStrings:QueueConnection"] = await queues.Resource.ConnectionStringExpression.GetValueAsync(CancellationToken.None);

85var token = await context.Credential.GetTokenAsync(requestContext, CancellationToken.None);

103var files = await a.Callback(new() { Model = serviceResource.TargetResource, ServiceProvider = executionContext.ServiceProvider }, CancellationToken.None).ConfigureAwait(false);

168var entries = await containerAnnotation.Callback(new() { Model = keycloakResource, ServiceProvider = app.Services }, CancellationToken.None); 195var entries = await containerAnnotation.Callback(new() { Model = keycloakResource, ServiceProvider = app.Services }, CancellationToken.None);

477var entries = await createServers.Callback(new() { Model = pgadmin, ServiceProvider = app.Services }, CancellationToken.None); 537var entries = await createBookmarks.Callback(new() { Model = pgweb, ServiceProvider = app.Services }, CancellationToken.None);

243public DistributedApplication Build() => BuildAsync(CancellationToken.None).Result;

48await hook.BeforeStartAsync(model, CancellationToken.None).DefaultTimeout(); 91await hook.BeforeStartAsync(model, CancellationToken.None).DefaultTimeout(); 139await hook.BeforeStartAsync(model, CancellationToken.None).DefaultTimeout();

157ResourcePublisher publisher = new(CancellationToken.None);

211await appExecutor.StopResourceAsync(reference, CancellationToken.None); 213await appExecutor.StartResourceAsync(reference, CancellationToken.None); 1144var ex = await Assert.ThrowsAsync<DistributedApplicationException>(async () => await appExecutor.StartResourceAsync(resourceReference, CancellationToken.None));

137await orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 141await orchestrator.StopResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 145var restartResourceTask = orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 149await orchestrator.StartResourceAsync(resourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 199await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 216await orchestrator.StopResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 220await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 273await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 289await orchestrator.StopResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 293await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.LongTimeoutTimeSpan); 354await orchestrator.StartResourceAsync(notStartedResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan); 372await orchestrator.StopResourceAsync(runningResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan); 379await orchestrator.StartResourceAsync(runningResourceEvent.ResourceId, CancellationToken.None).DefaultTimeout(TestConstants.ExtraLongTimeoutTimeSpan); 678await orchestrator.StopResourceAsync(serviceA.Metadata.Name, CancellationToken.None).DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout); 683await orchestrator.StartResourceAsync(serviceA.Metadata.Name, CancellationToken.None).DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout);

22var resolvedValue = await ExpressionResolver.ResolveAsync(testData.SourceIsContainer, testData.ValueProvider, string.Empty, CancellationToken.None); 28async Task<ResolvedValue> ResolveAsync() => await ExpressionResolver.ResolveAsync(testData.SourceIsContainer, testData.ValueProvider, string.Empty, CancellationToken.None); 99var connectionString = await ExpressionResolver.ResolveAsync(sourceIsContainer, csRef, "ContainerHostName", CancellationToken.None).DefaultTimeout();

125await foreach (var interaction in subscription.WithCancellation(CancellationToken.None)) 176await interactionService.CompleteInteractionAsync(interactionId, (_, _) => state, CancellationToken.None);

58await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 105await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 145await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 212await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 272await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 319await events.PublishAsync(new OnResourcesPreparedContext(CancellationToken.None)); 388await events.PublishAsync(new OnResourceStartingContext(CancellationToken.None, KnownResourceTypes.Container, parentResource.Resource, parentResource.Resource.Name)); 432await applicationEventing.PublishAsync(new ConnectionStringAvailableEvent(resource.Resource, app.Services), CancellationToken.None);

28var step = await reporter.CreateStepAsync(title, CancellationToken.None); 59var step = await reporter.CreateStepAsync("Parent Step", CancellationToken.None); 66var task = await step.CreateTaskAsync(statusText, CancellationToken.None); 99() => nonExistentStep.CreateTaskAsync("Test Task", CancellationToken.None)); 111var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 112await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None); 116() => step.CreateTaskAsync("Test Task", CancellationToken.None)); 130var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 136await step.CompleteAsync(completionText, isError ? CompletionState.CompletedWithError : CompletionState.Completed, CancellationToken.None); 161var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 162var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 169await task.UpdateAsync(newStatusText, CancellationToken.None); 192var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 193var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 196var dummyStep = await reporter.CreateStepAsync("Dummy Step", CancellationToken.None); 203() => invalidTask.UpdateAsync("New status", CancellationToken.None)); 214var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 215var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 216await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None); 220() => task.UpdateAsync("New status", CancellationToken.None)); 233var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 234var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 241await task.CompleteAsync(completionMessage, cancellationToken: CancellationToken.None); 268var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 269var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 270await step.CompleteAsync("Completed", CompletionState.Completed, CancellationToken.None); 274() => task.CompleteAsync(null, cancellationToken: CancellationToken.None)); 290await reporter.CompletePublishAsync(null, completionState, CancellationToken.None); 311await reporter.CompletePublishAsync(expectedStatusText, CompletionState.CompletedWithError, CancellationToken.None); 330var step1 = await reporter.CreateStepAsync("Step 1", CancellationToken.None); 331var step2 = await reporter.CreateStepAsync("Step 2", CancellationToken.None); 332var step3 = await reporter.CreateStepAsync("Step 3", CancellationToken.None); 334var task1 = await step1.CreateTaskAsync("Task 1", CancellationToken.None); 335await task1.CompleteAsync(null, cancellationToken: CancellationToken.None); 336await step1.CompleteAsync("Step 1 completed", CompletionState.Completed, CancellationToken.None); 338var task2 = await step2.CreateTaskAsync("Task 2", CancellationToken.None); 339await task2.CompleteAsync(null, cancellationToken: CancellationToken.None); 340await step2.CompleteAsync("Step 2 completed with warning", CompletionState.CompletedWithWarning, CancellationToken.None); 342var task3 = await step3.CreateTaskAsync("Task 3", CancellationToken.None); 343await task3.CompleteAsync(null, cancellationToken: CancellationToken.None); 344await step3.CompleteAsync("Step 3 failed", CompletionState.CompletedWithError, CancellationToken.None); 351await reporter.CompletePublishAsync(cancellationToken: CancellationToken.None); 367var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 368var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 371await task.CompleteAsync(null, cancellationToken: CancellationToken.None); 384var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 385var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 388await task.CompleteAsync(null, cancellationToken: CancellationToken.None); 392() => task.CompleteAsync(null, cancellationToken: CancellationToken.None)); 404var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 407await step.CompleteAsync("Complete", cancellationToken: CancellationToken.None); 411() => step.CompleteAsync("Complete again", cancellationToken: CancellationToken.None)); 423var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 424var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 427await task.CompleteAsync(null, cancellationToken: CancellationToken.None); 430await step.CompleteAsync("Step completed", CompletionState.Completed, CancellationToken.None); 435() => task.UpdateAsync("New status", CancellationToken.None)); 441() => task.CompleteAsync(null, cancellationToken: CancellationToken.None)); 446() => step.CreateTaskAsync("New Task", CancellationToken.None)); 456await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 488await reporter.CompleteInteractionAsync(promptId, responses, CancellationToken.None).DefaultTimeout(); 501var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 516var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 544var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 545var task1 = await step.CreateTaskAsync("Task 1", CancellationToken.None); 546var task2 = await step.CreateTaskAsync("Task 2", CancellationToken.None); 549await task1.SucceedAsync(null, CancellationToken.None); 550await task2.SucceedAsync(null, CancellationToken.None); 578var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 581await step.CompleteAsync("Step completed manually", CompletionState.Completed, CancellationToken.None); 603var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 604var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 612await taskInternal.WarnAsync(completionMessage, CancellationToken.None); 638var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 639var task = await step.CreateTaskAsync("Test Task", CancellationToken.None); 647await taskInternal.FailAsync(completionMessage, CancellationToken.None);

20await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 23var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 39await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 42var result = await step.SucceedAsync("Success message", CancellationToken.None); 57await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 58var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 61var result = await task.UpdateStatusAsync("Updated status", CancellationToken.None); 76await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 77var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 80var result = await task.SucceedAsync("Success message", CancellationToken.None); 94await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 95var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 98var result = await task.WarnAsync("Warning message", CancellationToken.None); 112await using var step = await reporter.CreateStepAsync("Test Step", CancellationToken.None); 113var task = await step.CreateTaskAsync("Initial status", CancellationToken.None); 116await task.FailAsync("Error message", CancellationToken.None);

62return WriteAsync(message, CancellationToken.None);

29_ = service.StartAsync(CancellationToken.None); 55_ = service.StartAsync(CancellationToken.None); 87_ = service.StartAsync(CancellationToken.None); 123_ = service.StartAsync(CancellationToken.None); 145_ = service.StartAsync(CancellationToken.None); 174_ = service.StartAsync(CancellationToken.None);

221var content = await config.Build(CancellationToken.None);

64await cache.GetAsync("myFakeKey", CancellationToken.None);

64await cacheStore.GetAsync("myFakeKey", CancellationToken.None);

79.OpenAsync(ResponseFactory, CancellationToken.None);

232CancellationToken.None, 242CancellationToken.None,

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

140CancellationToken.None);

155Task.Factory.StartNew(() => SingleThreadedSyncContext_CallbackUsingDefaultSyncCtx_SyncCallNotBlocked_Helper(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 220Task.Factory.StartNew(() => SingleThreadedSyncContext_SyncCallNotBlocked_Helper(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();

72Task.Factory.StartNew(() => TypedProxyTests.ServiceContract_TypedProxy_AsyncBeginEnd_Call(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 106Task.Factory.StartNew(() => TypedProxyTests.ServiceContract_TypedProxy_AsyncTask_Call(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 160Task.Factory.StartNew(() => TypedProxyTests.ServiceContract_TypedProxy_Synchronous_Call(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();

26Task.Factory.StartNew(() => TypedProxyTests.ServiceContract_TypedProxy_NetTcpBinding_AsyncBeginEnd_Call(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 40Task.Factory.StartNew(() => TypedProxyTests.ServiceContract_TypedProxy_NetTcpBinding_AsyncTask_Call(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();

232CancellationToken.None, 242CancellationToken.None,

30var spec = parser.GetSchemaGenerationSpec(CancellationToken.None);

14return await rootCommand.Parse(args).InvokeAsync(CancellationToken.None).ConfigureAwait(false);

1570var spec = parser.GetSchemaGenerationSpec(CancellationToken.None);

336Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Open_ChannelFactory(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 389Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Open_Proxy(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 440Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Close_ChannelFactory(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 490Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_Async_Close_Proxy(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();

210Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 224Task.Factory.StartNew(() => ServiceContractTests.BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_Async(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 614Task.Factory.StartNew(() => ServiceContractTests.NetTcp_NoSecurity_Streamed_RoundTrips_String(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait(); 628Task.Factory.StartNew(() => ServiceContractTests.NetTcp_NoSecurity_Streamed_Async_RoundTrips_String(), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()).Wait();

37Task.Factory.StartNew(callback, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 67Task.Factory.StartNew(callback, this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

47}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default); 68}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default); 92}, callback, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default); 124}, continuationState, CancellationToken.None, TaskContinuationOptions.HideScheduler, TaskScheduler.Default);

46_cancellationToken = CancellationToken.None;

66int count = await stream.ReadAsync(buffer, offset, currentBufferSize - offset, CancellationToken.None);

41return ReadAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult(); 98WriteAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();

35return ReadAsyncInternal(buffer, offset, count, CancellationToken.None).WaitForCompletion(); 64WriteAsyncInternal(buffer, offset, count, CancellationToken.None).WaitForCompletion();

122Task task = CloseOutputAsync(CancellationToken.None); 361return WebSocket.CloseAsync(_webSocketCloseDetails.OutputCloseStatus, _webSocketCloseDetails.OutputCloseStatusDescription, CancellationToken.None); 582CancellationToken.None);

1183Task.Factory.StartNew(s_receiveThreadSchedulerCallback, result, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

64value = CreateValue<MSBuildProj>(() => MSBuildProj.FromPathAsync(stringValue, null, System.Threading.CancellationToken.None).Result, option, stringValue);

68var cancellationToken = CancellationToken.None; 403var telemetryClient = await AppInsightsTelemetryClient.GetInstanceAsync(CancellationToken.None).ConfigureAwait(false);

233MSBuildProj binProj = MSBuildProj.FromPathAsync(binProjPath, null, CancellationToken.None).Result; 234ProcessRunner.ProcessResult result = binProj.BuildAsync(true, null, CancellationToken.None).Result; 243this_TestCaseProject.SaveAsync(this_TestCaseLogger, CancellationToken.None).Wait(); 245ProcessRunner.ProcessResult ret = this_TestCaseProject.BuildAsync(true, this_TestCaseLogger, CancellationToken.None).Result;

129this_TestCaseProject = await MSBuildProj.FromPathAsync(Path.Combine(this_TestCaseOutputDir, $"{testCaseName}.csproj"), null, CancellationToken.None); 157this_TestCaseProject = await MSBuildProj.FromPathAsync(Path.Combine(this_TestCaseOutputDir, $"{testClientFolder}.csproj"), null, CancellationToken.None); 158ProcessRunner.ProcessResult ret = await this_TestCaseProject.BuildAsync(true, this_TestCaseLogger, CancellationToken.None); 181await this_TestCaseProject.SaveAsync(this_TestCaseLogger, System.Threading.CancellationToken.None);

41var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None); 61var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None); 80var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None); 100var build = await MSBuildProj.ParseAsync(projectText, TestDir + "/MSBuildProjTests/Sample", null, CancellationToken.None);

17static readonly CancellationToken token = CancellationToken.None; 95result = ProcessRunner.RunAsync("dotnet-svcutil", options, project.DirectoryPath, redirectOutput: true, throwOnError: false, environmentVariables: envVars, logger: logger, cancellationToken: CancellationToken.None).Result; 156result = ProcessRunner.RunAsync("dotnet", $"run", project.DirectoryPath, redirectOutput: true, throwOnError: false, environmentVariables: envVars, logger: logger, cancellationToken: CancellationToken.None).Result;

178ProcessRunner.ProcessResult ret = ProcessRunner.TryRunAsync("dotnet", "tool uninstall -g dotnet-svcutil", currentDirectory, null, CancellationToken.None).Result; 185ret = ProcessRunner.TryRunAsync("dotnet", $"tool install --global --add-source {pkgPath} dotnet-svcutil --version {g_SvcutilPkgVersion}", currentDirectory, null, CancellationToken.None).Result; 259this_TestCaseProject = MSBuildProj.FromPathAsync(projectPath, null, CancellationToken.None).Result; 589var rootSolutionFolder = PathHelper.TryFindFileAsync("dotnet-svcutil.sln", parentDir, null, CancellationToken.None).Result;

34exitCode = Tool.MainAsync(args, this_TestCaseLogger, CancellationToken.None).Result; 249cmdOptions.ProcessBasicOptionsAsync(this_TestCaseLogger, CancellationToken.None).Wait(); 250cmdOptions.ResolveAsync(CancellationToken.None).Wait(); 295await cmdOptions.ProcessBasicOptionsAsync(this_TestCaseLogger, CancellationToken.None); 296await cmdOptions.ResolveAsync(CancellationToken.None);

260return rootCommand.Parse(args).InvokeAsync(CancellationToken.None);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

45var root = document.GetSyntaxRootSynchronously(CancellationToken.None); 47return Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None); 58var root = document.GetSyntaxRootSynchronously(CancellationToken.None); 60return Formatter.GetFormattedTextChanges(root, workspace.Services.SolutionServices, options, CancellationToken.None);

80return PrepareGlyphRequiredDataAsync(CancellationToken.None);

62CancellationToken.None).ConfigureAwait(false);

117var results = await testServer.ExecuteRequestAsync<LSP.CompletionParams, LSP.CompletionList>(LSP.Methods.TextDocumentCompletionName, completionParams, CancellationToken.None);

93CancellationToken.None);

68_storage = _storageService.GetStorageAsync(SolutionKey.ToSolutionKey(solution), CancellationToken.None).AsTask().GetAwaiter().GetResult();

18var result = await Microsoft.CodeAnalysis.StackTraceExplorer.StackTraceAnalyzer.AnalyzeAsync(Stack, CancellationToken.None);

79_solution = await _workspace.OpenSolutionAsync(solutionPath, progress: null, CancellationToken.None); 87await service.AddSemanticClassificationsAsync(document, span, ClassificationOptions.Default, result, CancellationToken.None);

66_ = _workspace.OpenSolutionAsync(_solutionPath, progress: null, CancellationToken.None).Result; 79await _diagnosticAnalyzerRunner.RunAsync(CancellationToken.None).ConfigureAwait(false);

78_solution = await _workspace.OpenSolutionAsync(solutionPath, progress: null, CancellationToken.None); 87var storage = await storageService.GetStorageAsync(SolutionKey.ToSolutionKey(_workspace.CurrentSolution), CancellationToken.None);

53var root = document.GetSyntaxRootAsync(CancellationToken.None).Result.WithAdditionalAnnotations(Formatter.Annotation); 68var formattedDoc = Formatter.FormatAsync(_document, Formatter.Annotation, _options, CancellationToken.None).Result; 69var formattedRoot = formattedDoc.GetSyntaxRootAsync(CancellationToken.None).Result;

65_ = _workspace.OpenSolutionAsync(_solutionPath, progress: null, CancellationToken.None).Result; 78await _incrementalAnalyzerRunner.RunAsync(CancellationToken.None).ConfigureAwait(false);

81var solution = _workspace.OpenSolutionAsync(_solutionPath, progress: null, CancellationToken.None).Result;

82var solution = _workspace.OpenSolutionAsync(_solutionPath, progress: null, CancellationToken.None).Result; 184var storage = await storageService.GetStorageAsync(SolutionKey.ToSolutionKey(_workspace.CurrentSolution), CancellationToken.None); 215g => Task.Run(() => SearchAsync(solution, g, priorityDocuments: ImmutableArray<Document>.Empty), CancellationToken.None)).ToArray(); 237() => Task.CompletedTask, CancellationToken.None);

91SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None); 98SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None); 104SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, _rootWithSimpleEdit, TimeSpan.MaxValue, CancellationToken.None); 110SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, _rootWithComplexEdit, TimeSpan.MaxValue, CancellationToken.None); 117SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None); 124SyntacticChangeRangeComputer.ComputeSyntacticChangeRange(_root, newRoot, TimeSpan.MaxValue, CancellationToken.None);

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

72}, CancellationToken.None); 74var reader = PipeReaderFactory.CreateFromStream(PipeOptions.Default, sslStream, CancellationToken.None);

37var session = await webTransportFeature.AcceptAsync(CancellationToken.None).DefaultTimeout(); // todo session is null here

21var stream = await session.OpenUnidirectionalStreamAsync(CancellationToken.None); 45var stream = await session.AcceptStreamAsync(CancellationToken.None); 53var stream2 = await session.AcceptStreamAsync(CancellationToken.None); 93Assert.Null(await session.AcceptStreamAsync(CancellationToken.None)); 94Assert.Null(await session.OpenUnidirectionalStreamAsync(CancellationToken.None));

42await stream.Transport.Output.WriteAsync(input, CancellationToken.None); 47var length = await stream.Transport.Input.AsStream().ReadAsync(memoryOut, CancellationToken.None);

35var session = await webTransportFeature.AcceptAsync(CancellationToken.None).DefaultTimeout();

463var sslServerAuthenticationOptions = await sslOptions.OnConnection(new TlsConnectionCallbackContext(), CancellationToken.None); 507var sslServerAuthenticationOptions = await tlsOptions.OnConnection(new TlsConnectionCallbackContext(), CancellationToken.None);

61}, CancellationToken.None);

138await webSocket.SendAsync(new ArraySegment<byte>(Encoding.ASCII.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None); 189await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); 202await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "CloseFromServer", CancellationToken.None); 215result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

130var response1 = await client.SendAsync(request1, CancellationToken.None); 187var response = await client.SendAsync(request1, CancellationToken.None); 214var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 298var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

94var response1 = await client.SendAsync(request1, CancellationToken.None); 154var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 256var response = await client.SendAsync(request, CancellationToken.None); 300var responseTask = client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 380var responseTask = client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 424var responseTask = client.SendAsync(request, CancellationToken.None); 566var sendTask = client.SendAsync(request, CancellationToken.None); 625var sendTask = client.SendAsync(request, CancellationToken.None); 681var ex = await Assert.ThrowsAnyAsync<HttpRequestException>(() => client.SendAsync(request, CancellationToken.None)).DefaultTimeout(); 820var response = await client.SendAsync(request, CancellationToken.None); 856var response1 = await client.SendAsync(request1, CancellationToken.None); 867var response2 = await client.SendAsync(request2, CancellationToken.None); 916var response1 = await client.SendAsync(request1, CancellationToken.None); 929var response2 = await client.SendAsync(request2, CancellationToken.None); 945var response3 = await client.SendAsync(request3, CancellationToken.None); 1375var response = await client.SendAsync(request, CancellationToken.None); 1427var response1 = await client.SendAsync(request1, CancellationToken.None); 1437var response2 = await client.SendAsync(request2, CancellationToken.None); 1494var response1 = await client.SendAsync(request1, CancellationToken.None); 1505var response2 = await client.SendAsync(request2, CancellationToken.None); 1551await client.SendAsync(request1, CancellationToken.None); 1565var response2 = await client.SendAsync(request2, CancellationToken.None); 1608var response1 = await client.SendAsync(request1, CancellationToken.None); 1668var response1 = await client.SendAsync(request1, CancellationToken.None); 1724var response1 = await client.SendAsync(request1, CancellationToken.None); 1781var responseTask1 = client.SendAsync(CreateHttp3Request(HttpMethod.Get, $"https://127.0.0.1:{port}/1"), CancellationToken.None); 1831var response3 = await client.SendAsync(CreateHttp3Request(HttpMethod.Get, $"https://127.0.0.1:{port}/3"), CancellationToken.None); 1890var responseTask = client.SendAsync(request1, CancellationToken.None); 1967var response1 = await client.SendAsync(request1, CancellationToken.None); 2045var responseTask = client.SendAsync(request, CancellationToken.None); 2145var responseTask = client.SendAsync(request, CancellationToken.None); 2197var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

61var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 107var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 149var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 198var sendTask = client.SendAsync(request, CancellationToken.None); 248var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 327var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 492var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

306var project = await workspace.OpenProjectAsync(projectFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 319var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 320var metricData = await CodeAnalysisMetricData.ComputeAsync(compilation!.Assembly, new CodeMetricsAnalysisContext(compilation, CancellationToken.None)).ConfigureAwait(false); 332var solution = await workspace.OpenSolutionAsync(solutionFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 352var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 353var metricData = await CodeAnalysisMetricData.ComputeAsync(compilation!.Assembly, new CodeMetricsAnalysisContext(compilation, CancellationToken.None)).ConfigureAwait(false);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

306var project = await workspace.OpenProjectAsync(projectFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 319var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 320var metricData = await CodeAnalysisMetricData.ComputeAsync(compilation!.Assembly, new CodeMetricsAnalysisContext(compilation, CancellationToken.None)).ConfigureAwait(false); 332var solution = await workspace.OpenSolutionAsync(solutionFile, cancellationToken: CancellationToken.None).ConfigureAwait(false); 352var compilation = await project.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 353var metricData = await CodeAnalysisMetricData.ComputeAsync(compilation!.Assembly, new CodeMetricsAnalysisContext(compilation, CancellationToken.None)).ConfigureAwait(false);

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

822var targetRoot = await targetDoc.GetSyntaxRootAsync(CancellationToken.None); 831CancellationToken.None); 842CancellationToken.None); 855CancellationToken.None); 868CancellationToken.None); 881CancellationToken.None); 894CancellationToken.None); 905CancellationToken.None); 918CancellationToken.None); 931CancellationToken.None); 942CancellationToken.None);

191var comp = await proj!.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 219var comp = await proj!.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 350var context = new CodeFixContext(doc!, d, (action, _) => actions.Add(action), CancellationToken.None); 361var operations = await actions[0].GetOperationsAsync(CancellationToken.None).ConfigureAwait(false); 448cancellationToken: CancellationToken.None); 455var operations = await fixAllCodeAction!.GetOperationsAsync(CancellationToken.None).ConfigureAwait(false);

191var comp = await proj!.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 219var comp = await proj!.GetCompilationAsync(CancellationToken.None).ConfigureAwait(false); 261.GetAnalysisResultAsync(CancellationToken.None).ConfigureAwait(false); 351var context = new CodeFixContext(doc!, d, (action, _) => actions.Add(action), CancellationToken.None); 362var operations = await actions[0].GetOperationsAsync(CancellationToken.None).ConfigureAwait(false); 449cancellationToken: CancellationToken.None); 456var operations = await fixAllCodeAction!.GetOperationsAsync(CancellationToken.None).ConfigureAwait(false);

15public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request) => SendAsync(request, CancellationToken.None);

32public CancellationToken DefaultCancellationToken { get; set; } = CancellationToken.None;

29var context = new CodeFixContext(document, analyzerDiagnostic, (a, d) => actions.Add(a), CancellationToken.None); 63var operations = await codeAction.GetOperationsAsync(CancellationToken.None);

34var result = await Classifier.GetClassifiedSpansAsync(doc, textSpan, CancellationToken.None); 73var semanticModel = await document.GetSemanticModelAsync(CancellationToken.None).ConfigureAwait(false); 79var root = await document.GetSyntaxRootAsync(CancellationToken.None).ConfigureAwait(false); 95return braceMatcher.FindBraces(model, token, caretPosition, CancellationToken.None); 103var highlights = highlighter.GetDocumentHighlights(model, token, caretPosition, CancellationToken.None);

46await test.RunAsync(CancellationToken.None);

42await test.RunAsync(CancellationToken.None); 76await test.RunAsync(CancellationToken.None);

31await test.RunAsync(CancellationToken.None); 45await test.RunAsync(CancellationToken.None);

28var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

86var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);

184var validationTask = _validatorTypeInfo.ValidateAsync(_editContext.Model, validateContext, CancellationToken.None);

28var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

86var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);

212await OnConnectionDownAsync(CancellationToken.None); 222await OnCircuitDownAsync(CancellationToken.None);

710await circuitHost.UpdateRootComponents(new() { Operations = [addOperation] }, null, CancellationToken.None); 726await circuitHost.UpdateRootComponents(new() { Operations = [updateOperation] }, null, CancellationToken.None); 738await circuitHost.UpdateRootComponents(new() { Operations = [removeOperation] }, null, CancellationToken.None);

24var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(_jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None).DefaultTimeout(); 162var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None); 182var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None); 219cancellationToken: CancellationToken.None); 260cancellationToken: CancellationToken.None); 296var token1 = isToken1Cancelable ? cts.Token : CancellationToken.None; 297var token2 = isToken1Cancelable ? CancellationToken.None : cts.Token; 313CancellationToken.None, 314CancellationToken.None); 348var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime ?? _jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None);

366=> InvokeAsync<TValue>(identifier, cancellationToken: CancellationToken.None, args: args);

404cancellationToken = CancellationToken.None;

113return RunAsyncCore(CancellationToken.None);

23var pullFromJSDataStream = PullFromJSDataStream.CreateJSDataStream(_jsRuntime, jsStreamReference, totalLength: 100, cancellationToken: CancellationToken.None); 108var pullFromJSDataStream = PullFromJSDataStream.CreateJSDataStream(runtime, jsStreamReference, totalLength: data.Length, cancellationToken: CancellationToken.None); 134=> await InvokeAsync<TValue>(identifier, CancellationToken.None, args);

240}, CancellationToken.None, flags, TaskScheduler.Current);

43}, message, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

19/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

21/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

49return new CacheableKeyRing(CancellationToken.None, now + extension, KeyRing);

369CancellationToken.None, // GetKeyRingFromCompletedTaskUnsynchronized will need to react if this becomes cancellable 411CancellationToken.None,

51var cacheableKeyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.Now, keyRing);

263var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 294var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 298var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 }); 330var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 334var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 });

163getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None }, 248getCacheExpirationTokenReturnValues: new[] { CancellationToken.None }, 501getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None }, 536getCacheExpirationTokenReturnValues: new[] { CancellationToken.None, CancellationToken.None }, 582expirationToken: CancellationToken.None, 609expirationToken: CancellationToken.None, 615expirationToken: CancellationToken.None, 621expirationToken: CancellationToken.None, 650expirationToken: CancellationToken.None, 656expirationToken: CancellationToken.None, 701expirationToken: CancellationToken.None, 738.Returns(new CacheableKeyRing(CancellationToken.None, StringToDateTime("2015-03-02 00:00:00Z"), updatedKeyRing)); 831expirationToken: CancellationToken.None,

54await JsonRequestHelpers.SendMessage(serverCallContext, SerializerOptions, response, CancellationToken.None);

39return WriteAsyncCore(message, CancellationToken.None);

101await WriteResponseMessage(response, encoding, e, options, CancellationToken.None); 352await fs.DrainAsync(CancellationToken.None);

175host.StartAsync(CancellationToken.None).GetAwaiter().GetResult();

156public Task<IFormCollection> ReadFormAsync() => ReadFormAsync(CancellationToken.None);

281await socket.CloseOutputAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

177/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 193/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

40/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

35public CancellationToken ApplicationStarted => CancellationToken.None; 37public CancellationToken ApplicationStopping => CancellationToken.None; 39public CancellationToken ApplicationStopped => CancellationToken.None;

1465await ws.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

30var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory); 71var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory); 94var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory);

402await client.ConnectAsync(new Uri(address), CancellationToken.None); 404await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout(); 405var result = await client.ReceiveAsync(new ArraySegment<byte>(new byte[1024]), CancellationToken.None).DefaultTimeout();

51cancellationToken: CancellationToken.None); 52await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); 100await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); 193await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); 298await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout(); 332await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout(); 376var transport = ws.ProcessRequestAsync(context, CancellationToken.None); 386await feature.Client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).DefaultTimeout();

26await response.SendFileAsync("bob", 1, 3, CancellationToken.None); 31Assert.Equal(CancellationToken.None, fakeFeature.Token); 42await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None); 82await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None); 97await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None);

273.Setup(s => s.SendFileAsync(path, 0, null, CancellationToken.None)) 313Assert.Equal(CancellationToken.None, sendFile.Token); 340Assert.Equal(CancellationToken.None, sendFile.Token); 360Assert.Equal(CancellationToken.None, sendFile.Token);

348Assert.Equal(CancellationToken.None, sendFile.Token);

27get => GetClientCertificateAsync(CancellationToken.None).Result;

34_cancel = contextAccessor?.HttpContext?.RequestAborted ?? CancellationToken.None;

42_cancel = services?.GetService<IHttpContextAccessor>()?.HttpContext?.RequestAborted ?? CancellationToken.None;

77await userStore.SetUserNameAsync(user, email, CancellationToken.None); 78await emailStore.SetEmailAsync(user, email, CancellationToken.None);

27.OpenAsync(ResponseFactory, CancellationToken.None);

17store.Setup(s => s.CreateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 18store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable(); 19store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 37store.Setup(s => s.UpdateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 38store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable(); 39store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 65store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable(); 82store.Setup(s => s.FindByNameAsync(role.Name, CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable(); 101store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable();

72store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 73store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable(); 74store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 91store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 92store.Setup(s => s.GetSecurityStampAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.SecurityStamp)).Verifiable(); 93store.Setup(s => s.SetSecurityStampAsync(user, It.IsAny<string>(), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 111store.Setup(s => s.CreateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 112store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable(); 113store.Setup(s => s.GetEmailAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.Email)).Verifiable(); 114store.Setup(s => s.SetNormalizedEmailAsync(user, normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 115store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 135store.Setup(s => s.DeleteAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 162store.Setup(s => s.DeleteAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Failed(new IdentityErrorDescriber().ConcurrencyFailure())).Verifiable(); 188store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable(); 189store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 190store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 208store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.UserName)).Verifiable(); 209store.Setup(s => s.GetEmailAsync(user, CancellationToken.None)).Returns(Task.FromResult(user.Email)).Verifiable(); 210store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 211store.Setup(s => s.SetNormalizedEmailAsync(user, normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 212store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 230store.Setup(s => s.SetUserNameAsync(user, "foo", CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 231store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)).Returns(Task.FromResult("foo")).Verifiable(); 232store.Setup(s => s.SetNormalizedUserNameAsync(user, normalizer.NormalizeName("foo"), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 233store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable(); 250store.Setup(s => s.FindByIdAsync(user.Id, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 268store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName(user.UserName), CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 285store.Setup(s => s.FindByNameAsync(user.UserName, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 304store.Setup(s => s.FindByEmailAsync(normalizer.NormalizeEmail(user.Email), CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 321store.Setup(s => s.FindByEmailAsync(user.Email, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 345store.Setup(s => s.FindByEmailAsync("@Foo", CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 363store.Setup(s => s.FindByNameAsync("#Foo", CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 383store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 386store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 389store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None)) 393store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 394store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 397store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 400store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None)) 411store.Verify(s => s.AddToRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None), Times.Once()); 421store.Setup(s => s.AddToRoleAsync(user, "#A", CancellationToken.None)) 424store.Setup(s => s.AddToRoleAsync(user, "#B", CancellationToken.None)) 427store.Setup(s => s.AddToRoleAsync(user, "#C", CancellationToken.None)) 431store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 432store.Setup(s => s.IsInRoleAsync(user, "#A", CancellationToken.None)) 435store.Setup(s => s.IsInRoleAsync(user, "#B", CancellationToken.None)) 438store.Setup(s => s.IsInRoleAsync(user, "#C", CancellationToken.None)) 450store.Verify(s => s.AddToRoleAsync(user, "#C", CancellationToken.None), Times.Once()); 461store.Setup(s => s.AddToRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 464store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 485store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 488store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 491store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None)) 494store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 495store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 498store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 501store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("C"), CancellationToken.None)) 522store.Setup(s => s.RemoveFromRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 525store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("A"), CancellationToken.None)) 528store.Setup(s => s.IsInRoleAsync(user, normalizer.NormalizeName("B"), CancellationToken.None)) 548store.Setup(s => s.AddClaimsAsync(user, claims, CancellationToken.None)) 551store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 572store.Setup(s => s.AddClaimsAsync(user, It.IsAny<IEnumerable<Claim>>(), CancellationToken.None)) 575store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 604store.Setup(s => s.ReplaceClaimAsync(user, It.IsAny<Claim>(), It.IsAny<Claim>(), CancellationToken.None)) 607store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).Returns(Task.FromResult(IdentityResult.Success)).Verifiable(); 640store.Setup(s => s.GetPasswordHashAsync(user, CancellationToken.None)) 643store.Setup(s => s.SetPasswordHashAsync(user, It.IsAny<string>(), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 735store.Setup(s => s.RemoveClaimsAsync(user, claims, CancellationToken.None)) 738store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 766store.Setup(s => s.RemoveClaimsAsync(user, It.IsAny<IEnumerable<Claim>>(), CancellationToken.None)) 769store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 794store.Setup(s => s.SetPasskeyAsync(user, passkey, CancellationToken.None)).Returns(Task.CompletedTask).Verifiable(); 795store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 814store.Setup(s => s.GetPasskeysAsync(user, CancellationToken.None)).Returns(Task.FromResult(passkeys)).Verifiable(); 832store.Setup(s => s.FindByPasskeyIdAsync(credentialId, CancellationToken.None)).Returns(Task.FromResult(user)).Verifiable(); 850store.Setup(s => s.RemovePasskeyAsync(user, credentialId, CancellationToken.None)).Returns(Task.CompletedTask).Verifiable(); 851store.Setup(s => s.UpdateAsync(user, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 2159store.Setup(s => s.FindByEmailAsync("DUPE@EMAIL.COM", CancellationToken.None)) 2162store.Setup(s => s.GetUserIdAsync(user2, CancellationToken.None)) 2165store.Setup(s => s.GetUserNameAsync(user, CancellationToken.None)) 2168store.Setup(s => s.GetEmailAsync(user, CancellationToken.None))

185await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 186await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

131await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 132await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

185await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 186await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

131await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 132await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

273.Setup(s => s.SendFileAsync(path, 0, null, CancellationToken.None)) 313Assert.Equal(CancellationToken.None, sendFile.Token); 340Assert.Equal(CancellationToken.None, sendFile.Token); 360Assert.Equal(CancellationToken.None, sendFile.Token);

348Assert.Equal(CancellationToken.None, sendFile.Token);

115await readStream.DrainAsync(CancellationToken.None); 134await readStream.DrainAsync(CancellationToken.None);

99await readStream.DrainAsync(CancellationToken.None); 118await readStream.DrainAsync(CancellationToken.None);

115await readStream.DrainAsync(CancellationToken.None); 134await readStream.DrainAsync(CancellationToken.None);

220=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

130await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 140await WriteInRandomChunksAsync(Payload, oc, CancellationToken.None); 146await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 157await WriteInRandomChunks(Payload, pipe, CancellationToken.None); 163await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 174var entry = await OutputCacheEntryFormatter.GetAsync(Key, _store, CancellationToken.None);

128var cache = await ConnectAsync(CancellationToken.None).ConfigureAwait(false);

74var payload = await store.GetAsync(key, CancellationToken.None);

53_context.Items[OwinConstants.CallCancelled] = CancellationToken.None; 446{ OwinConstants.CommonKeys.LoadClientCertAsync, new FeatureMap<ITlsConnectionFeature>(feature => new Func<Task>(() => feature.GetClientCertificateAsync(CancellationToken.None))) },

129adapter.UpstreamTask.ContinueWith(adapter.EnsureCompleted, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

125Assert.Equal(CancellationToken.None, env["owin.CallCancelled"]);

181=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

185=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

55var consumer = ConsumeAsync(pipe.Reader, CancellationToken.None); 73var consumer = ConsumeAsync(pipe.Reader, CancellationToken.None);

172=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

71await stream.SendFileAsync(path, 0, null, CancellationToken.None);

1052return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); 1102return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); 1152await feature.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);

33return CancellationToken.None;

51_disconnectToken = CancellationToken.None; 64_disconnectToken = CancellationToken.None;

184=> TaskToApm.Begin(ReadAsync(buffer, offset, size, CancellationToken.None), callback, state);

74=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

84var cert = await tls.GetClientCertificateAsync(CancellationToken.None); 109var cert = await tls.GetClientCertificateAsync(CancellationToken.None);

31server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 52server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 69server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 90server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 106server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 117server.StartAsync(new DummyApplication(), CancellationToken.None).Wait();

613server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

392await httpContext.Response.SendFileAsync(_absoluteFilePath, 0, null, CancellationToken.None); 412await httpContext.Response.SendFileAsync(_absoluteFilePath, 0, null, CancellationToken.None);

45await sendFile.SendFileAsync(string.Empty, 0, null, CancellationToken.None); 68return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None); 87return sendFile.SendFileAsync(RelativeFilePath, 0, null, CancellationToken.None); 106return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None); 125sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None).Wait(); 126return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None); 145return sendFile.SendFileAsync(AbsoluteFilePath, 0, FileLength / 2, CancellationToken.None); 166sendFile.SendFileAsync(AbsoluteFilePath, 1234567, null, CancellationToken.None)); 185sendFile.SendFileAsync(AbsoluteFilePath, 0, 1234567, CancellationToken.None)); 202return sendFile.SendFileAsync(AbsoluteFilePath, 0, 0, CancellationToken.None); 222return sendFile.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None); 243return sendFile.SendFileAsync(AbsoluteFilePath, 0, 10, CancellationToken.None); 264return sendFile.SendFileAsync(AbsoluteFilePath, 0, 0, CancellationToken.None); 291return sendFile.SendFileAsync(AbsoluteFilePath, 0, 10, CancellationToken.None); 315await httpContext.Response.SendFileAsync(emptyFilePath, 0, null, CancellationToken.None); 317await httpContext.Response.Body.WriteAsync(new byte[10], 0, 10, CancellationToken.None); 650await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, CancellationToken.None);

348await server.StartAsync(new DummyApplication(), CancellationToken.None);

102}, CancellationToken.None);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

131server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); 161server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

50server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

43: this(loggerFactory, deploymentParameters: deploymentParameters, applicationBaseUri: applicationBaseUri, contentRoot: string.Empty, hostShutdownToken: CancellationToken.None)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

193AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None)); 214var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 242var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 305await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 336await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);

112mockMessageBody.Setup(m => m.ReadAsync(CancellationToken.None)).Returns(new ValueTask<ReadResult>(new ReadResult(default, isCanceled: false, isCompleted: true)));

114mockHttpResponseControl.Setup(m => m.WritePipeAsync(It.IsAny<ReadOnlyMemory<byte>>(), CancellationToken.None)).Returns(new ValueTask<FlushResult>(new FlushResult()));

352async () => await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None)); 371await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 393async () => await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None)); 416await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 442await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 469await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 500await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 528await server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None); 577await server.StartAsync(new DummyApplication(), CancellationToken.None); 635await server.StartAsync(new DummyApplication(), CancellationToken.None); 826await server.StartAsync(new DummyApplication(), CancellationToken.None).DefaultTimeout(); 905await server.StopAsync(CancellationToken.None).DefaultTimeout(); 964await server.StartAsync(new DummyApplication(), CancellationToken.None).DefaultTimeout(); 971await server.StopAsync(CancellationToken.None).DefaultTimeout(); 986server.StartAsync(new DummyApplication(context => Task.CompletedTask), CancellationToken.None).GetAwaiter().GetResult();

145var listenerTask = listener.OnTlsClientHelloAsync(transportConnection, CancellationToken.None); 189var listenerTask = listener.OnTlsClientHelloAsync(transportConnection, CancellationToken.None); 242await listener.OnTlsClientHelloAsync(transportConnection, CancellationToken.None);

62return (QuicConnectionListener)await transportFactory.BindAsync(endpoint, features, cancellationToken: CancellationToken.None); 77return (QuicConnectionListener)await transportFactory.BindAsync(endpoint, features, cancellationToken: CancellationToken.None);

32var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: null, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout(); 49var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: features, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout(); 72await quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: features, cancellationToken: CancellationToken.None).AsTask().DefaultTimeout();

181=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

262/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 315/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 426/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 448/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 470/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 615CancellationToken.None, 668/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 1499var sendHandshakeResult = await startingConnectionState.Connection.Transport.Output.FlushAsync(CancellationToken.None).ConfigureAwait(false);

22/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 36/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 51/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 67/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 84/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 102/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 121/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 141/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 162/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 184/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 207/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 221/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

23/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 41/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 60/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 80/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 101/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 123/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 146/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 170/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 195/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 221/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 248/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 266/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

22/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 37/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 53/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 70/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 88/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 107/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 127/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 148/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 170/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 193/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 217/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

24/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 42/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 61/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 81/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 102/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 124/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 147/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 171/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 196/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 222/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 249/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 267/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

22/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 39/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 57/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 76/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 96/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 117/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 139/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 162/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 186/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 211/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 237/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

19/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 34/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 50/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 67/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 85/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 104/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 124/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 145/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 167/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 190/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 214/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 227/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 241/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 256/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 272/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 289/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 307/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 326/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 346/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 367/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 389/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 412/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

228/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

35/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 45/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 55/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 65/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 75/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 85/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 96/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 106/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 116/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 125/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 134/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

21/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

16/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 25/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

100await ws.ConnectAsync(new Uri(socketUrl), CancellationToken.None).DefaultTimeout(); 104await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None).DefaultTimeout(); 108var result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout(); 114await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout(); 116result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout(); 138await ws.ConnectAsync(new Uri(socketUrl), CancellationToken.None).DefaultTimeout(); 143await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Binary, endOfMessage: false, CancellationToken.None).DefaultTimeout(); 147var result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout(); 153await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout(); 155result = await ws.ReceiveAsync(buffer, CancellationToken.None).DefaultTimeout();

352var result = await caller.InvokeAsync<int>("GetResult", 1, CancellationToken.None);

27Assert.Equal(CancellationToken.None, send.CancellationToken); 51Assert.Equal(CancellationToken.None, send.CancellationToken); 80Assert.Equal(CancellationToken.None, send1.CancellationToken); 88Assert.Equal(CancellationToken.None, send2.CancellationToken); 223Assert.Equal(CancellationToken.None, send.CancellationToken);

30Task.Factory.StartNew(Run, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

58var res = await SpaProxy.PerformProxyRequest(context, httpClient, baseUriTask, CancellationToken.None, true);

88public CancellationToken ApplicationStarted => CancellationToken.None;

69return ReadAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();

221var response = await invoker.SendAsync(message, CancellationToken.None); 316var responseTask = invoker.SendAsync(message, CancellationToken.None); 344Assert.Throws<NotSupportedException>(() => invoker.Send(message, CancellationToken.None)); 363HttpResponseMessage response = await invoker.SendAsync(message, CancellationToken.None); 366response = await invoker.SendAsync(message, CancellationToken.None); 502responseTask = invoker.SendAsync(message, CancellationToken.None);

256var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => client.SendAsync(message, CancellationToken.None)); 587var receiveResult = await websocket.ReceiveAsync(new System.ArraySegment<byte>(receiveArray), CancellationToken.None); 590await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None); 596await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None); 615var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None); 617await clientSocket.SendAsync(new System.ArraySegment<byte>(hello), WebSocketMessageType.Text, true, CancellationToken.None); 619await clientSocket.SendAsync(new System.ArraySegment<byte>(world), WebSocketMessageType.Binary, true, CancellationToken.None); 620await clientSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None); 626var result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None); 631result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None); 636result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None); 658await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None); 667await websocket.CloseAsync(WebSocketCloseStatus.InternalServerError, closeReason, CancellationToken.None); 682var clientSocket = await client.ConnectAsync(new Uri("wss://localhost"), CancellationToken.None); 684var result = await clientSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); 709var receiveResult = await websocket.ReceiveAsync(new ArraySegment<byte>(receiveArray), CancellationToken.None); 712await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal Closure", CancellationToken.None); 718await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None); 774var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None); 776await Assert.ThrowsAsync<IOException>(async () => await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None)); 793var receiveResult = await websocket.ReceiveAsync(new System.ArraySegment<byte>(receiveArray), CancellationToken.None); 795await websocket.SendAsync(sendBuffer, receiveResult.MessageType, receiveResult.EndOfMessage, CancellationToken.None); 807var clientSocket = await client.ConnectAsync(new System.Uri("http://localhost"), CancellationToken.None); 809await clientSocket.SendAsync(new System.ArraySegment<byte>(hello), WebSocketMessageType.Text, true, CancellationToken.None); 816var result = await clientSocket.ReceiveAsync(new System.ArraySegment<byte>(buffer), CancellationToken.None);

19await pair.ClientSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None); 22var result = await pair.ServerSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); 36await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None); 39var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); 51await pair.ClientSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None); 54var result = await pair.ServerSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); 66await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None); 69var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); 81await pair.ServerSocket.SendAsync(new ArraySegment<byte>(sendBuffer), WebSocketMessageType.Binary, endOfMessage: true, cancellationToken: CancellationToken.None); 84var result = await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); 94await pair.ClientSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None);

125var result = await webSocket.ReceiveAsync(serverBuffer, CancellationToken.None); 142await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);

29await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 49await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 71var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 79await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 81await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 96var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 105await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 106await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 121var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 130await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 131await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 147var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 158await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 159await client.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 178var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 186new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None); 194new ArraySegment<byte>(serverBuffer, totalReceived, serverBuffer.Length - totalReceived), CancellationToken.None); 205await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 206await client.SendAsync(new ArraySegment<byte>(originalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); 209await client.SendAsync(new ArraySegment<byte>(originalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None); 212await client.SendAsync(new ArraySegment<byte>(originalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); 226await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 231await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 233var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); 251await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 256await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 258var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); 276await webSocket.SendAsync(new ArraySegment<byte>(originalData), WebSocketMessageType.Binary, true, CancellationToken.None); 281await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 287result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer, receivedCount, clientBuffer.Length - receivedCount), CancellationToken.None); 309await webSocket.SendAsync(new ArraySegment<byte>(originalData, 0, 2), WebSocketMessageType.Binary, false, CancellationToken.None); 310await webSocket.SendAsync(new ArraySegment<byte>(originalData, 2, 2), WebSocketMessageType.Binary, false, CancellationToken.None); 311await webSocket.SendAsync(new ArraySegment<byte>(originalData, 4, 7), WebSocketMessageType.Binary, true, CancellationToken.None); 316await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 318var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); 325new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); 332new ArraySegment<byte>(clientBuffer, totalReceived, clientBuffer.Length - totalReceived), CancellationToken.None); 353var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 363await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 364await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 380await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 385await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 387var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); 409var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 416await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); 421await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 422await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 439var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 446await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); 451await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 452await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 455await client.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 470await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeDescription, CancellationToken.None); 473var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(serverBuffer), CancellationToken.None); 483await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 485var result = await client.ReceiveAsync(new ArraySegment<byte>(clientBuffer), CancellationToken.None); 494await client.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); 558await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 625await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 735await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None); 793await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);

82/// The default value is <see cref="CancellationToken.None"/>.</param>

20=> section.ReadAsStringAsync(CancellationToken.None).AsTask();

232CancellationToken.None, 242CancellationToken.None,

232CancellationToken.None, 242CancellationToken.None,

244var effectiveDiagnostic = compilationOptions.FilterDiagnostic(Diagnostic.Create(this, Location.None), CancellationToken.None);

324CancellationToken.None,

67public CancellationToken CancellationToken => CancellationToken.None; 235return GetAnalyzerDiagnosticsAsync(CancellationToken.None); 286return GetAllDiagnosticsAsync(CancellationToken.None); 1199var effectiveDiagnostic = compilation.Options.FilterDiagnostic(diagnostic, CancellationToken.None); 1241catch (Exception ex) when (AnalyzerExecutor.HandleAnalyzerException(ex, analyzer, info: null, wrappedOnAnalyzerException, analyzerExceptionFilter: null, CancellationToken.None)) 1253catch (Exception ex) when (AnalyzerExecutor.HandleAnalyzerException(ex, suppressor, info: null, wrappedOnAnalyzerException, analyzerExceptionFilter: null, CancellationToken.None)) 1260isEnabledWithAnalyzerConfigOptions: _ => false, getSupportedDiagnosticDescriptors, getSupportedSuppressionDescriptors, CancellationToken.None); ;

140/// The default value is <see cref="CancellationToken.None"/>.

40GeneratorInitializationContext generatorInitContext = new GeneratorInitializationContext(CancellationToken.None);

417return this.GetText(CancellationToken.None).ToString();

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

232parameters = [tree, rule.Id, CancellationToken.None, null];

35public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

30public void Dispose() => Free(CancellationToken.None);

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

140/// The default value is <see cref="CancellationToken.None"/>.

232CancellationToken.None, 242CancellationToken.None,

158if (provider.TryGetDiagnosticValue(tree, descriptor.Id, CancellationToken.None, out severity) || 159provider.TryGetGlobalDiagnosticValue(descriptor.Id, CancellationToken.None, out severity))

84? ((ICompilationUnitSyntax)token.Parent!.SyntaxTree!.GetRoot(CancellationToken.None)).EndOfFileToken

47using (Logger.LogBlock(FunctionId.Formatting_ContextInitialization, CancellationToken.None))

56return this.GetTextChanges(CancellationToken.None).Count > 0;

51using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))

229var indentation = Finder.GetIndentationOfCurrentPosition(this.Tree, token, LineToBeIndented.Start, CancellationToken.None);

332using var reader = SymbolKeyReader.GetReader(key, compilation: null!, ignoreAssemblyKey: false, CancellationToken.None);

250=> base.Initialize(data, CancellationToken.None);

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

101channel, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

493return _lock.WaitAsync(CancellationToken.None);

46return test.RunAsync(CancellationToken.None);

37return test.RunAsync(CancellationToken.None);

232CancellationToken.None, 242CancellationToken.None,

232CancellationToken.None, 242CancellationToken.None,

265!csTree.IsGeneratedCode(this.Compilation.Options.SyntaxTreeOptionsProvider, CancellationToken.None),

74CancellationToken.None);

3831if (!FilterAndAppendAndFreeDiagnostics(diagnostics, ref runtimeMDVersionDiagnostics, CancellationToken.None))

5467=> lazyDefaultState ??= syntaxTree.IsGeneratedCode(Compilation.Options.SyntaxTreeOptionsProvider, CancellationToken.None)

75var code = tree.IsGeneratedCode(binder.Compilation.Options.SyntaxTreeOptionsProvider, CancellationToken.None)

135CancellationToken.None, // We don't have a tree so there's no need to pass cancellation to the SyntaxTreeOptionsProvider

594this.ContainingSymbol.ForceComplete(locationOpt: null, filter: null, cancellationToken: CancellationToken.None);

331? ((CompilationUnitSyntax)structure.SyntaxTree.GetRoot(CancellationToken.None)).EndOfFileToken

94return GenerateMemberAccess(nameof(CancellationToken.None));

1322var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1325var commitOperations = await action.GetOperationsAsync(CancellationToken.None); 1347var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1350var commitOperations = await action.GetOperationsAsync(CancellationToken.None); 1377var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1380var commitOperations = await action.GetOperationsAsync(CancellationToken.None);

308Assert.True(compilerTreeOptions.TryGetDiagnosticValue(tree, "cs0169", CancellationToken.None, out var severity)); 310Assert.True(compilerTreeOptions.TryGetDiagnosticValue(tree, "warning01", CancellationToken.None, out severity));

34var cancellationToken = CancellationToken.None;

51var cancellationToken = CancellationToken.None;

82var parsedDocument = ParsedDocument.CreateSynchronously(document, CancellationToken.None);

262Assert.Contains("void Ext(this C5 c, string s)", (await updatedDocument.GetTextAsync(CancellationToken.None)).ToString()); 266Assert.Contains(@"c.Ext(""two"");", (await updatedDocument.GetTextAsync(CancellationToken.None)).ToString()); 349Assert.Contains("void Ext(this C5 c, string s, int newIntegerParameter)", (await updatedDocument.GetTextAsync(CancellationToken.None)).ToString()); 353Assert.Contains(@"c.Ext(""two"", 123);", (await updatedDocument.GetTextAsync(CancellationToken.None)).ToString());

2981var tags = tagger!.GetAllTags(new NormalizedSnapshotSpanCollection(buffer.CurrentSnapshot.GetFullSpan()), CancellationToken.None);

234var context = new CodeRefactoringContext(document, new TextSpan(), refactorings.Add, CancellationToken.None); 239var operations = await action.GetOperationsAsync(CancellationToken.None); 247var result = await operation.TryApplyAsync(workspace, originalSolution, CodeAnalysisProgress.None, CancellationToken.None);

889var modifiedSolution = await moveTypeService.GetModifiedSolutionAsync(documentToModify, textSpan, MoveTypeOperationKind.MoveTypeNamespaceScope, CancellationToken.None).ConfigureAwait(false); 901var formattedDocument = await Formatter.FormatAsync(modifiedDocument, CSharpSyntaxFormattingOptions.Default, CancellationToken.None).ConfigureAwait(false);

69await suggestedAction.GetPreviewAsync(CancellationToken.None); 85_ = await suggestedAction.GetActionSetsAsync(CancellationToken.None); 110var context = new CodeRefactoringContext(document, span, (a) => codeActions.Add(a), CancellationToken.None);

97var context = new CodeRefactoringContext(document, span, refactorings.Add, CancellationToken.None); 101var previews = await editHandler.GetPreviewsAsync(workspace, action.GetPreviewOperationsAsync(CancellationToken.None).Result, CancellationToken.None);

117var operations = await action.GetOperationsAsync(CancellationToken.None); 223var operations = await changeNamespaceAction.GetOperationsAsync(CancellationToken.None);

732var result = await NameDeclarationInfo.GetDeclarationInfoAsync(document, position, CancellationToken.None);

3516var origComp = await workspace.CurrentSolution.Projects.Single().GetRequiredCompilationAsync(CancellationToken.None); 3535var commit = await service.GetChangeAsync(document, completionItem, commitCharacter: null, CancellationToken.None);

1296options: CompletionOptions.Default, cancellationToken: CancellationToken.None);

31CancellationToken.None);

25var results = await nameResolver.DoAsync(CancellationToken.None); 36var results = await debugInfo.ResolveBreakpointsAsync(workspace.CurrentSolution, "goo", CancellationToken.None);

111var actualTerms = await getter.GetProximityExpressionsAsync(document, position, CancellationToken.None); 119var actualValid = await getter.IsValidAsync(semanticSnapshot, position, expression, CancellationToken.None);

244var formatted = await CSharpDecompiledSourceService.FormatDocumentAsync(document, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

107var compilerEngineCompilation = (CSharpCompilation)compilerEngineWorkspace.CurrentSolution.Projects.Single().GetRequiredCompilationAsync(CancellationToken.None).Result; 281var compilerEngineCompilation = (CSharpCompilation)compilerEngineWorkspace.CurrentSolution.Projects.Single().GetRequiredCompilationAsync(CancellationToken.None).Result; 340var compilerEngineCompilation = (CSharpCompilation)(await compilerEngineWorkspace.CurrentSolution.Projects.Single().GetRequiredCompilationAsync(CancellationToken.None)); 784var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);

72Assert.Same(snapshot1, document1.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot()); 73Assert.Same(snapshot2, document2.GetTextSynchronously(CancellationToken.None).FindCorrespondingEditorTextSnapshot()); 88var spans2 = await trackingSession.GetSpansAsync(solution, document1.Id, document1.FilePath, CancellationToken.None); 91var spans3 = await trackingSession.GetSpansAsync(solution, document2.Id, document2.FilePath, CancellationToken.None); 95var spans4 = await trackingSession.GetAdjustedTrackingSpansAsync(document1, snapshot1, CancellationToken.None); 102AssertEx.Empty(await trackingSession.GetAdjustedTrackingSpansAsync(document2, snapshot2, CancellationToken.None)); 119var spans6 = await trackingSession.GetAdjustedTrackingSpansAsync(document1, snapshot1, CancellationToken.None);

20var actual = syntaxTree.IsPossibleDeconstructionDesignation(position, CancellationToken.None);

18=> Assert.Equal(validLocation, syntaxTree.IsNamespaceContext(position, CancellationToken.None));

20var leftToken = syntaxTree.FindTokenOnLeftOfPosition(position, CancellationToken.None);

18=> Assert.Equal(validLocation, syntaxTree.IsTypeContext(position, CancellationToken.None));

21Assert.False(tree.IsInInactiveRegion(pos, CancellationToken.None)); 30Assert.True(tree.IsInInactiveRegion(pos, CancellationToken.None));

130CodeCleanupOptions = await document.GetCodeCleanupOptionsAsync(CancellationToken.None), 134document, testDocument.SelectedSpans.Single(), localFunction, options, CancellationToken.None); 150var (doc, _) = await result.GetDocumentAsync(CancellationToken.None); 167var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None); 170var (result, status) = await validator.GetValidSelectionAsync(CancellationToken.None); 192var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None); 199var (_, status) = await validator.GetValidSelectionAsync(CancellationToken.None);

10043var tree = await service.ExtractMethodAsync(document: null!, textSpan: default, localFunction: false, options: default, CancellationToken.None); 10061await service.ExtractMethodAsync(document, textSpan: default, localFunction: false, ExtractMethodGenerationOptions.GetDefault(project.Services), CancellationToken.None);

765document, enabledDiagnostics, CodeAnalysisProgress.None, CancellationToken.None); 867document, enabledDiagnostics, CodeAnalysisProgress.None, CancellationToken.None);

365var syntaxRoot = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 367var node = Formatter.Format(syntaxRoot, spans, workspace.Services.SolutionServices, options, rules: default, CancellationToken.None); 2231var formattedRoot = Formatter.Format(root, workspace.Services.SolutionServices, options, CancellationToken.None);

74var documentSyntax = await ParsedDocument.CreateAsync(document, CancellationToken.None); 96var changes = formatter.FormatToken(token, CancellationToken.None);

3166var documentSyntax = await ParsedDocument.CreateAsync(document, CancellationToken.None); 3196var changes = formatter.FormatRange(tokenRange.Value.Item1, tokenRange.Value.Item2, CancellationToken.None);

71var formattedDocument = await Formatter.FormatAsync(document, spans: null, options: null, CancellationToken.None);

118var changes = await textDiffService.GetTextChangesAsync(currentDocument!, priorDocument, CancellationToken.None).ConfigureAwait(false); 129var results = await intentSource.ComputeIntentsAsync(intentContext, CancellationToken.None).ConfigureAwait(false);

504var spans = await lineSeparatorService.GetLineSeparatorsAsync(document, root.FullSpan, CancellationToken.None);

1284CancellationToken.None); 1438var changedRoot = await changedDocument.GetRequiredSyntaxRootAsync(CancellationToken.None);

151await searcher.SearchAsync(NavigateToSearchScope.Solution, CancellationToken.None); 191await searcher.SearchAsync(NavigateToSearchScope.Solution, CancellationToken.None); 228await searcher.SearchAsync(NavigateToSearchScope.Solution, CancellationToken.None); 265await searcher.SearchAsync(NavigateToSearchScope.Solution, CancellationToken.None); 296await searcher.SearchAsync(NavigateToSearchScope.Solution, CancellationToken.None); 355await searcher.SearchAsync(NavigateToSearchScope.Project, CancellationToken.None); 405await searcher.SearchAsync(NavigateToSearchScope.Document, CancellationToken.None); 465await searcher.SearchAsync(NavigateToSearchScope.Document, CancellationToken.None);

132var file = await service.GetGeneratedFileAsync(workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None).ConfigureAwait(false); 232var mainCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false);

38using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), useDefaultSymbolServers: false, new TelemetryMessage(CancellationToken.None), CancellationToken.None); 65using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), useDefaultSymbolServers: false, new TelemetryMessage(CancellationToken.None), CancellationToken.None); 90using var result = await service.GetDocumentDebugInfoReaderAsync(GetDllPath(path), useDefaultSymbolServers: false, new TelemetryMessage(CancellationToken.None), CancellationToken.None);

45var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None); 73var result = await service.LoadSourceDocumentAsync(path, sourceDocument, Encoding.UTF8, new TelemetryMessage(CancellationToken.None), useExtendedTimeout: false, CancellationToken.None);

787var file = await service.GetGeneratedFileAsync(workspace, project, symbol, signaturesOnly: false, options: options, cancellationToken: CancellationToken.None).ConfigureAwait(false); 845var mainCompilation = await project.GetRequiredCompilationAsync(CancellationToken.None).ConfigureAwait(false); 868var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None); 889var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None); 911var file = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None); 932var fileOne = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: false, options: MetadataAsSourceOptions.Default, cancellationToken: CancellationToken.None); 937var compilation = await project.GetCompilationAsync(CancellationToken.None); 939var fileTwo = await service.GetGeneratedFileAsync(project.Solution.Workspace, project, symbolTwo, signaturesOnly: false, MetadataAsSourceOptions.Default, CancellationToken.None);

179var info = await provider.GetQuickInfoAsync(new QuickInfoContext(document, position, SymbolDescriptionOptions.Default, CancellationToken.None));

75var info = await service.GetQuickInfoAsync(document, position, SymbolDescriptionOptions.Default, CancellationToken.None); 137var info = await service.GetQuickInfoAsync(document, position, SymbolDescriptionOptions.Default, CancellationToken.None); 306var info = await service.GetQuickInfoAsync(document, position, SymbolDescriptionOptions.Default, CancellationToken.None);

559Assert.Null(await provider.GetQuickInfoAsync(new QuickInfoContext(document, position, SymbolDescriptionOptions.Default, CancellationToken.None))); 570var info = await provider.GetQuickInfoAsync(new QuickInfoContext(document, position, SymbolDescriptionOptions.Default, CancellationToken.None)); 586navigationActionFactory, CancellationToken.None);

95CancellationToken.None);

546=> new SpeculationAnalyzer((ExpressionSyntax)initialNode, (ExpressionSyntax)replacementNode, initialModel, CancellationToken.None).ReplacementChangesSemantics();

34var regions = await service.GetStringIndentationRegionsAsync(document, root.FullSpan, CancellationToken.None).ConfigureAwait(false);

35var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None);

32return (await outliningService.GetBlockStructureAsync(document, options, CancellationToken.None)).Spans;

532var symkey = SymbolKey.Create(typeSym02, CancellationToken.None);

354var resolution = SymbolKey.ResolveString(symbolKey, emptyCompilation, ignoreAssemblyKey: true, out var failureReason, CancellationToken.None);

82var sid = SymbolKey.Create(originalSymbol, CancellationToken.None); 96var sid1 = SymbolKey.Create(symbol1, CancellationToken.None); 97var sid2 = SymbolKey.Create(symbol2, CancellationToken.None);

36inferredType = typeInference.InferType(await document.ReuseExistingSpeculativeModelAsync(position, CancellationToken.None), position, objectAsDefault: true, cancellationToken: CancellationToken.None); 40inferredType = typeInference.InferType(await document.ReuseExistingSpeculativeModelAsync(node?.Span ?? textSpan, CancellationToken.None), node, objectAsDefault: true, cancellationToken: CancellationToken.None);

32var delegateType = typeInference.InferDelegateType(await document.GetSemanticModelAsync(), node, CancellationToken.None);

228.GetSyntaxTreeAsync(CancellationToken.None); 235.GetSyntaxTreeAsync(CancellationToken.None); 661var partialDoc2Z = doc2Z.WithFrozenPartialSemantics(CancellationToken.None); 718var syntaxTree = await doc.GetSyntaxTreeAsync(CancellationToken.None);

23this.RecommendKeywordsAsync = (position, context) => Task.FromResult(_recommender.RecommendKeywords(position, context, CancellationToken.None));

21RecommendKeywordsAsync = (position, context) => Task.FromResult(Recommender.RecommendKeywords(position, context, CancellationToken.None));

22this.RecommendKeywordsAsync = (position, context) => Task.FromResult(_recommender.RecommendKeywords(position, context, CancellationToken.None));

72if (tree.IsInNonUserCode(position, CancellationToken.None) && !absent) 78var context = CSharpSyntaxContext.CreateContext(document, semanticModel, position, CancellationToken.None);

20this.RecommendKeywordsAsync = (position, context) => Task.FromResult(_recommender.RecommendKeywords(position, context, CancellationToken.None));

23this.RecommendKeywordsAsync = (position, context) => Task.FromResult(_recommender.RecommendKeywords(position, context, CancellationToken.None));

603var entry = compilation.GetEntryPoint(CancellationToken.None); 625var entry = compilation.GetEntryPoint(CancellationToken.None); 714var entry = compilation.GetEntryPoint(CancellationToken.None); 791var entry = compilation.GetEntryPoint(CancellationToken.None); 841var entry = compilation.GetEntryPoint(CancellationToken.None); 885var entry = compilation.GetEntryPoint(CancellationToken.None); 905var entry = compilation.GetEntryPoint(CancellationToken.None); 969var entry = compilation.GetEntryPoint(CancellationToken.None); 989var entry = compilation.GetEntryPoint(CancellationToken.None);

9861var method = comp.GetEntryPoint(System.Threading.CancellationToken.None);

13291cancellationToken: CancellationToken.None);

2730var symbolSynthesized = class1.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;

84compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None); 160compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None);

12514CancellationToken.None); 12530CancellationToken.None); 12546CancellationToken.None); 12602CancellationToken.None);

32var te = queue.DequeueAsync(CancellationToken.None);

3270var analysisResult = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzers, CancellationToken.None); 3316var analysisResult = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzers, CancellationToken.None); 3357var tree1SemanticDiagnostics = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel1, filterSpan: null, ImmutableArray.Create<DiagnosticAnalyzer>(analyzer1), CancellationToken.None); 3608var diagnostics = await compWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, filterSpan: null, CancellationToken.None); 3700await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, analyzersToQuery, CancellationToken.None) : 3701await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, analyzersToQuery, CancellationToken.None); 3706await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, CancellationToken.None) : 3707await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel1, filterSpan: null, CancellationToken.None); 3762CancellationToken.None); 3777CancellationToken.None); 3818CancellationToken.None); 3889var diagnostics = await compilation.WithAnalyzers(analyzers, options).GetAnalyzerDiagnosticsAsync(CancellationToken.None); 3892var analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile, CancellationToken.None); 3896analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(CancellationToken.None); 3931var diagnostics = await compilation.WithAnalyzers(analyzers, options).GetAnalyzerDiagnosticsAsync(CancellationToken.None); 3934var analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile1, CancellationToken.None); 3936analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile2, CancellationToken.None); 3940analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile1, singleAnalyzerArray, CancellationToken.None); 3942analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(additionalFile2, singleAnalyzerArray, CancellationToken.None); 3945analysisResult = await compilation.WithAnalyzers(analyzers, options).GetAnalysisResultAsync(CancellationToken.None); 4338? await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel.SyntaxTree, filterSpan, analyzers, CancellationToken.None) 4339: await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel.SyntaxTree, filterSpan, CancellationToken.None); 4344? await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(semanticModel.SyntaxTree, filterSpan, analyzers, CancellationToken.None) 4345: await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(semanticModel.SyntaxTree, filterSpan, CancellationToken.None); 4352? await compilationWithAnalyzers.GetAnalysisResultAsync(additionalTextFile, filterSpan, analyzers, CancellationToken.None) 4353: await compilationWithAnalyzers.GetAnalysisResultAsync(additionalTextFile, filterSpan, CancellationToken.None); 4360? await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan, analyzers, CancellationToken.None) 4361: await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan, CancellationToken.None); 4366? await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan, analyzers, CancellationToken.None) 4367: await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan, CancellationToken.None); 4400analyzerExceptionFilter: null, reportAnalyzer: false, severityFilter, trackSuppressedDiagnosticIds: false, out var newCompilation, CancellationToken.None); 4403_ = newCompilation.GetDiagnostics(CancellationToken.None); 4404_ = await driver.GetDiagnosticsAsync(newCompilation, CancellationToken.None); 4441var diagnostics = await compWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, filterSpan: null, CancellationToken.None);

719var diagnostics1 = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan: null, analyzers, CancellationToken.None); 723var diagnostics2 = await compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(semanticModel, filterSpan: null, analyzers, CancellationToken.None);

800tasks[i] = Task.Run(() => compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, null, CancellationToken.None)); 853tasks[i] = Task.Run(() => compilationWithAnalyzers.GetAnalyzerSemanticDiagnosticsAsync(model, null, CancellationToken.None)); 881var diagnostics = await compilationWithAnalyzers.GetAnalyzerSyntaxDiagnosticsAsync(tree, CancellationToken.None); 911_ = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None); 920_ = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan: null, CancellationToken.None); 964var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None); 1190var result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None); 1198result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, filterSpan: null, CancellationToken.None); 1207result = await compilationWithAnalyzers.GetAnalysisResultAsync(semanticModel, span, CancellationToken.None); 1251var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None); 1649var syntaxResult = await compilationWithAnalyzers.GetAnalysisResultAsync(tree1, CancellationToken.None); 1678var result = await compilationWithAnalyzers.GetAnalysisResultAsync(model1, filterSpan: localDecl.Span, CancellationToken.None); 1824var result = await compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None);

82=> _recommender.RecommendKeywords(position, context, CancellationToken.None);

94return GenerateMemberAccess(nameof(CancellationToken.None));

488document, span, DiagnosticKind.All, CancellationToken.None); 491var allFixes = (await fixService.GetFixesAsync(document, span, CancellationToken.None))

42tree, position.Value, CancellationToken.None, out var breakpointSpan);

124return await analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newDocument.Project, baseActiveStatements, newActiveStatementSpans.NullToEmpty(), lazyCapabilities, log, CancellationToken.None); 754var result = await analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newDocument.Project, baseActiveStatements, [], capabilities, log, CancellationToken.None);

33if (!Regex.IsMatch(document.GetTextSynchronously(CancellationToken.None).ToString(), "#nullable ?enable")) 49if (!Regex.IsMatch(document.GetTextSynchronously(CancellationToken.None).ToString(), "#nullable ?restore"))

79var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None); 83var executeResult = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, options, traceSource, CancellationToken.None); 280var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None); 329var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None); 332var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, options, traceSource, CancellationToken.None); 398var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None); 401var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, options, traceSource, CancellationToken.None); 459var compileResult = service.CompileQuery(solution.Services, query, s_referenceAssembliesDir, traceSource, CancellationToken.None); 462var result = await service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, options, traceSource, CancellationToken.None);

1322var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1325var commitOperations = await action.GetOperationsAsync(CancellationToken.None); 1347var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1350var commitOperations = await action.GetOperationsAsync(CancellationToken.None); 1377var previewOperations = await action.GetPreviewOperationsAsync(CancellationToken.None); 1380var commitOperations = await action.GetOperationsAsync(CancellationToken.None);

469var testMethods = await testMethodFinder.GetPotentialTestMethodsAsync(workspace.CurrentSolution.GetRequiredDocument(testDocument.Id), span, CancellationToken.None); 483var testMethods = await testMethodFinder.GetPotentialTestMethodsAsync(workspace.CurrentSolution.GetRequiredDocument(testDocument.Id), span, CancellationToken.None); 484var semanticModel = await workspace.CurrentSolution.GetRequiredDocument(testDocument.Id).GetRequiredSemanticModelAsync(CancellationToken.None); 490var matchFound = testMethods.Any(m => testMethodFinder.IsMatch(semanticModel, m, expectedTestName, CancellationToken.None));

25163}, CancellationToken.None) 25171comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None) 25232}, CancellationToken.None) 25242comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None) 25322}, CancellationToken.None) 25336comp.GetDiagnostics(CompilationStage.Declare, includeEarlierStages: true, symbolFilter: null, CancellationToken.None)

1694var result = userFunc(10, CancellationToken.None); 1695var userResult = userFunc(10, CancellationToken.None); 1700Assert.Throws<InvalidOperationException>(() => throwsFunc(20, CancellationToken.None)); 1701Assert.Throws<UserFunctionException>(() => userThrowsFunc(20, CancellationToken.None)); 1705userThrowsFunc(20, CancellationToken.None); 1717Assert.Throws<OperationCanceledException>(() => otherTimeoutFunc(30, CancellationToken.None)); 1718Assert.Throws<UserFunctionException>(() => userOtherTimeoutFunc(30, CancellationToken.None));

186GeneratorInitializationContext init = new GeneratorInitializationContext(CancellationToken.None); 194init = new GeneratorInitializationContext(CancellationToken.None); 202init = new GeneratorInitializationContext(CancellationToken.None); 210init = new GeneratorInitializationContext(CancellationToken.None); 2056driver = driver.RunGenerators(compilation, CancellationToken.None);

897error = comp.GetDiagnostics(cancellationToken: CancellationToken.None);

942_root = CloneNodeAsRoot(_underlyingTree.GetCompilationUnitRoot(CancellationToken.None));

355var bridge = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single(); 387Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); //not needed

150var bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods; 161bridgeMethods = sourceType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods;

942Assert.False(derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any()); 1013var synthesizedExplicitImpls = (from m in derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.MethodKind select m).ToArray(); 1082var synthesizedExplicitImpls = (from m in @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.Name select m).ToArray(); 1655var synthesizedExplicitImpl = classC.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single(); 1715Assert.Equal(0, classC.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); 1867derived.ForceComplete(locationOpt: null, filter: null, cancellationToken: CancellationToken.None); 1900var bridgeMethod = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single(); 2036var synthesized = derivedType.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single();

3462comp.GetDiagnosticsForSyntaxTree(CompilationStage.Declare, tree, null, includeEarlierStages: false, cancellationToken: CancellationToken.None); 3557comp.GetDiagnosticsForSyntaxTree(CompilationStage.Declare, tree1, null, includeEarlierStages: false, cancellationToken: CancellationToken.None).Verify(

94a.ForceComplete(null, filter: null, CancellationToken.None);

65var method2ExplicitImpl = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single(); 112var method2ExplicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods; 159Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); 208Assert.Equal(0, baseClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); 221Assert.Equal(0, derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); 528var class1SynthesizedExplicitImpls = class1.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods; 543var class2Method2SynthesizedExplicitImpl = class2.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Single(); 556var class3SynthesizedExplicitImpls = (from m in class3.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods orderby m.Name select m).ToArray(); 604Assert.False(@class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any()); 701Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length); 735var explicitImpls = @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods; 775Assert.Equal(0, @class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Length);

52CancellationToken = CancellationToken.None;

331? ((CompilationUnitSyntax)structure.SyntaxTree.GetRoot(CancellationToken.None)).EndOfFileToken

60var formatted = await Formatter.FormatAsync(changedDoc, SyntaxAnnotation.ElasticAnnotation, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

90? await ImportAdder.AddImportsFromSymbolAnnotationAsync(doc, addImportOptions, CancellationToken.None) 91: await ImportAdder.AddImportsFromSyntaxesAsync(doc, addImportOptions, CancellationToken.None); 95var formatted = await Formatter.FormatAsync(imported, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None); 102var reduced = await Simplifier.ReduceAsync(imported, simplifierOptions, CancellationToken.None); 103var formatted = await Formatter.FormatAsync(reduced, SyntaxAnnotation.ElasticAnnotation, formattingOptions, CancellationToken.None); 868var compilation = await document.Project.GetCompilationAsync(CancellationToken.None); 869var compilerDiagnostics = compilation.GetDiagnostics(CancellationToken.None); 874var syntaxRoot = await document.GetSyntaxRootAsync(CancellationToken.None).ConfigureAwait(false); 878var editor = await DocumentEditor.CreateAsync(document, CancellationToken.None).ConfigureAwait(false); 889? await ImportAdder.AddImportsFromSymbolAnnotationAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false) 890: await ImportAdder.AddImportsFromSyntaxesAsync(documentWithAttribute, addImportOptions, CancellationToken.None).ConfigureAwait(false); 892var formatted = await Formatter.FormatAsync(imported, formattingOptions, CancellationToken.None);

56document = await Simplifier.ReduceAsync(document, CSharpSimplifierOptions.Default, CancellationToken.None); 57document = await Formatter.FormatAsync(document, Formatter.Annotation, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 58document = await Formatter.FormatAsync(document, SyntaxAnnotation.ElasticAnnotation, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

4891var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, _workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None).ToFullString();

71var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 130var formatted = Formatter.Format(newRoot, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 133var elasticOnlyFormatted = Formatter.Format(newRoot, SyntaxAnnotation.ElasticAnnotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 136var annotationFormatted = Formatter.Format(newRoot, Formatter.Annotation, workspace.Services.SolutionServices, options, CancellationToken.None).ToFullString(); 180var newCompilation = Formatter.Format(compilation, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

158var result = Formatter.Format(root, TextSpan.FromBounds(0, 0), workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

4846var newProperty = Formatter.Format(property, workspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 8438Formatter.Format(block, new AdhocWorkspace().Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None); 9582=> Formatter.Format(SyntaxFactory.StructDeclaration("S"), DefaultWorkspace.Services.SolutionServices, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

46var result1 = Formatter.Format(root1, document.Project.Solution.Services, options, CancellationToken.None); 59var result2 = Formatter.Format(root2, document.Project.Solution.Services, options, CancellationToken.None);

1586var formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None); 1622var formatted = Formatter.Format(tree, workspace.Services.SolutionServices, options, CancellationToken.None);

40var newDocument = await organizeImportsService.OrganizeImportsAsync(document, options, CancellationToken.None); 90var newDocument = await organizeImportsService.OrganizeImportsAsync(document, options, CancellationToken.None);

232CancellationToken.None, 242CancellationToken.None,

106using (Logger.LogBlock(FunctionId.Tagger_AdornmentManager_OnLayoutChanged, CancellationToken.None)) 202using (Logger.LogBlock(FunctionId.Tagger_AdornmentManager_UpdateInvalidSpans, CancellationToken.None))

95return CancellationToken.None;

284using (Logger.LogBlock(FunctionId.Tagger_SyntacticClassification_TagComputer_GetTags, CancellationToken.None)) 343span.Snapshot.AsText(), span.Span.ToTextSpan(), classifiedSpans, CancellationToken.None); 355var cancellationToken = CancellationToken.None;

130CompleteComment(args.SubjectBuffer, args.TextView, InsertOnCharacterTyped, CancellationToken.None); 183CompleteComment(args.SubjectBuffer, args.TextView, InsertOnEnterTyped, CancellationToken.None);

64await proxy.SetFileLoggingDirectoryAsync(logDirectory, CancellationToken.None).ConfigureAwait(false);

63var configFileDirectoryOptions = project.State.GetAnalyzerOptionsForPath(givenFolder.FullName, CancellationToken.None);

72CancellationToken.None).ConfigureAwait(true); 87_threadingContext, workspace, result.NavigationDocumentId, position: 0, CancellationToken.None).ConfigureAwait(false);

142await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(CancellationToken.None);

137_ = _navigateToLinkService.TryNavigateToLinkAsync(uri, CancellationToken.None);

157_inlineRenameSessionDurationLogBlock = Logger.LogBlock(FunctionId.Rename_InlineSession, CancellationToken.None); 206using (Logger.LogBlock(FunctionId.Rename_CreateOpenTextBufferManagerForAllOpenDocs, CancellationToken.None)) 565var replacementInfo = await _conflictResolutionTask.JoinAsync(CancellationToken.None).ConfigureAwait(false); 666var cancellationToken = CancellationToken.None; 848cancellationToken = CancellationToken.None;

189new InlineRenameLocation(document, span), GetTriggerText(document, span), CancellationToken.None); 214var sourceText = document.GetTextSynchronously(CancellationToken.None); 228using (Logger.LogBlock(FunctionId.Rename_OnTextBufferChanged, CancellationToken.None))

298_ = _expandedItemsTaskCancellationSeries.CreateNext(CancellationToken.None);

45_ = navigateToLinkService.TryNavigateToLinkAsync(Uri, CancellationToken.None);

80if (document.TryGetTextSynchronously(document.Workspace.CurrentSolution, CancellationToken.None) is { } sourceText)

70await _stateMachine.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(CancellationToken.None); 177await _stateMachine.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(CancellationToken.None);

81using (Logger.LogBlock(FunctionId.Rename_Tracking_BufferChanged, CancellationToken.None))

63await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(CancellationToken.None);

76var text = document.GetTextSynchronously(CancellationToken.None); 77var version = document.GetTextVersionSynchronously(CancellationToken.None); 85var text = document.GetTextSynchronously(CancellationToken.None); 86var version = document.GetTextVersionSynchronously(CancellationToken.None); 94var text = document.GetTextSynchronously(CancellationToken.None); 95var version = document.GetTextVersionSynchronously(CancellationToken.None);

35CancellationToken.None);

22public string Documentation => _documentation ??= _parameter.DocumentationFactory(CancellationToken.None).GetFullText();

185var documentation = _signatureHelpItem.DocumentationFactory(CancellationToken.None).ToList();

24=> GetDesiredIndentation(line, CancellationToken.None);

49CancellationToken.None);

105await copilotCodeAnalysisService.StartRefinementSessionAsync(oldDocument, newDocument, convertedPrimaryDiagnostic, CancellationToken.None).ConfigureAwait(false);

291=> _provider.ProduceTagsAsync(context, CancellationToken.None);

374cancellationToken = CancellationToken.None; 602using (Logger.LogBlock(FunctionId.Tagger_TagSource_ProcessNewTags, CancellationToken.None))

47using (Logger.LogBlock(FunctionId.TextStructureNavigator_GetExtentOfWord, CancellationToken.None)) 105using (Logger.LogBlock(FunctionId.TextStructureNavigator_GetSpanOfEnclosing, CancellationToken.None)) 137using (Logger.LogBlock(FunctionId.TextStructureNavigator_GetSpanOfFirstChild, CancellationToken.None)) 173using (Logger.LogBlock(FunctionId.TextStructureNavigator_GetSpanOfNextSibling, CancellationToken.None)) 225using (Logger.LogBlock(FunctionId.TextStructureNavigator_GetSpanOfPreviousSibling, CancellationToken.None))

72CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

31var foundSpan = await braceMatcher.FindMatchingSpanAsync(document, position, braceMatchingOptions, CancellationToken.None);

36await service.AddBracePairsAsync(document, new TextSpan(0, text.Length), bracePairs, CancellationToken.None);

64var semanticModel = document.GetRequiredSemanticModelAsync(CancellationToken.None).AsTask().Result;

267await service.AddSemanticClassificationsAsync(document, spans, options, result, CancellationToken.None); 268await service.AddEmbeddedLanguageClassificationsAsync(document, spans, options, result, CancellationToken.None); 274var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 278service.AddSyntacticClassifications(root, spans, results, CancellationToken.None);

36declarationSyntaxNode, cap, CancellationToken.None); 63annotatedDocument.Id, declarationSyntaxNode, CancellationToken.None); 89annotatedDocument.Id, declarationSyntaxNode, CancellationToken.None); 115annotatedDocument.Id, declarationSyntaxNode, CancellationToken.None);

64var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 65var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None); 66var parameter = GetParameterSymbolInfo(workspace, semanticModel, root, position, CancellationToken.None); 69var context = new ArgumentContext(provider, semanticModel, position, parameter, previousDefaultValue, CancellationToken.None);

645var commit = await service.GetChangeAsync(document, completionItem, commitChar, CancellationToken.None); 746var textChange = (await service.GetChangeAsync(document, firstItem, commitChar, CancellationToken.None)).TextChange;

35var result = await service.GetDataTipInfoAsync(document, position, includeKind: true, CancellationToken.None); 52var result = await DataTipInfoGetter.GetInfoAsync(document, position, includeKind: true, CancellationToken.None);

82CancellationToken.None); 95CancellationToken.None); 103CancellationToken.None); 107var options = (ExtractInterfaceOptionsResult)action.GetOptions(CancellationToken.None); 116this.OriginalSolution, changedOptions, CodeAnalysisProgress.None, CancellationToken.None); 119operation.Apply(Workspace, CancellationToken.None);

26=> (new SimpleFindUsagesContext(), CancellationToken.None);

35await document.GetCodeCleanupOptionsAsync(CancellationToken.None); 38var formattedDocument = await formattingService.FormatNewDocumentAsync(document, hintDocument: null, cleanupOptions, CancellationToken.None);

183var documentSyntax = await ParsedDocument.CreateAsync(document, CancellationToken.None).ConfigureAwait(false); 214var newRootNode = Formatter.Format(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None); 227var result = Formatter.GetFormattedTextChanges(root, spans, workspace.Services.SolutionServices, options, rules, CancellationToken.None); 289var result = Formatter.Format(node, workspace.Services.SolutionServices, options, CancellationToken.None);

39var parsedDocument = await ParsedDocument.CreateAsync(document, CancellationToken.None); 63var parsedDocument = await ParsedDocument.CreateAsync(document, CancellationToken.None);

62service.AddHighlights(root, position, highlightSpans, CancellationToken.None);

65var destination = selectedType.ContainingNamespace.GetAllTypes(CancellationToken.None).First(t => t.ToDisplayString() == DestinationName);

38var result = await service.GetLocationsAsync(document, textSpans, CancellationToken.None);

37var result = await service.GetLocationsAsync(document, textSpans, CancellationToken.None);

107var relevantNodes = await document.GetRelevantNodesAsync<TNode>(selection, allowEmptyNodes, CancellationToken.None).ConfigureAwait(false);

88solution = await documentRenameResult.UpdateSolutionAsync(solution, CancellationToken.None);

160var items = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None); 177_ = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None); 229Assert.Equal(expectedTestItem.MethodDocumentation, actualSignatureHelpItem.DocumentationFactory(CancellationToken.None).GetFullText()); 249var classifiedSpans = actualSignatureHelpItem.DocumentationFactory(CancellationToken.None).ToClassifiedSpans().ToList(); 401var items = await signatureHelpProvider.GetItemsAsync(document, cursorPosition, triggerInfo, options, CancellationToken.None);

44var result = await service.GetTestAccessor().TryRenameAsync(buffer.CurrentSnapshot.GetSpan(span.Single().ToSpan()), replacement, CancellationToken.None);

31var actual = await service.GetSpansAsync(document, CancellationToken.None);

24var root = await document.GetSyntaxRootAsync(CancellationToken.None); 47outliner.CollectBlockSpans(previousToken, node, actualRegions, options, CancellationToken.None);

26outliner.CollectBlockSpans(trivia, actualRegions, options, CancellationToken.None);

40var items = await service.GetTaskListItemsAsync(document, TaskListItemDescriptor.Parse(descriptors), CancellationToken.None);

45CancellationToken.None,

63using (await SharedData.TestSerializationGate.DisposableWaitAsync(CancellationToken.None))

170var document = threadingContext.JoinableTaskFactory.Run(() => workspace.CurrentSolution.GetSourceGeneratedDocumentAsync(testDocument.Id, CancellationToken.None).AsTask());

333Dim completionItems = session.GetComputedItems(CancellationToken.None) 354Dim completionItems = session.GetComputedItems(CancellationToken.None) 407Dim items = session.GetComputedItems(CancellationToken.None).Items 417Dim items = session.GetComputedItems(CancellationToken.None).Items 441Dim items = session.GetComputedItems(CancellationToken.None) 527Dim items = session.GetComputedItems(CancellationToken.None) 534Dim item = session.GetComputedItems(CancellationToken.None).SelectedItem 541Return session.GetComputedItems(CancellationToken.None).Items.Select(Function(item) GetRoslynCompletionItem(item)).ToList() 572Dim computedItems = session.GetComputedItems(CancellationToken.None) 579Dim computedItems = session.GetComputedItems(CancellationToken.None) 587Dim computedItems = session.GetComputedItems(CancellationToken.None) 594operations.SelectCompletionItem(session.GetComputedItems(CancellationToken.None).Items.Single(Function(i) i.DisplayText = displayText)) 697Assert.Equal(documentation, Me.CurrentSignatureHelpPresenterSession.SelectedItem.DocumentationFactory(CancellationToken.None).GetFullText())

27Return (Context, CancellationToken.None)

60document, TextSpan.FromBounds(0, 0), new DefaultCodeActionRequestPriorityProvider(), CancellationToken.None); 85_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 112var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 145cancellationToken: CancellationToken.None); 152cancellationToken: CancellationToken.None); 181cancellationToken: CancellationToken.None); 211cancellationToken: CancellationToken.None); 280var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 305document, TextSpan.FromBounds(0, 0), new DefaultCodeActionRequestPriorityProvider(), CancellationToken.None); 752return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 853var txtDocumentCodeFixes = await tuple.codeFixService.GetFixesAsync(txtDocument, TextSpan.FromBounds(0, 1), CancellationToken.None); 861var solution = await codeAction.GetChangedSolutionInternalAsync(txtDocument.Project.Solution, CodeAnalysisProgress.None, CancellationToken.None); 863Assert.Equal("Additional Document", txtDocument.GetTextSynchronously(CancellationToken.None).ToString()); 864Assert.Equal($"Additional Document{fixer1.Title}", changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString()); 870var logDocumentCodeFixes = await tuple.codeFixService.GetFixesAsync(logDocument, TextSpan.FromBounds(0, 1), CancellationToken.None); 1020var root = await sourceDocument.GetRequiredSyntaxRootAsync(CancellationToken.None); 1030var diagnostics = await analyzerService.ForceAnalyzeProjectAsync(sourceDocument.Project, CancellationToken.None); 1055root = await sourceDocument.GetRequiredSyntaxRootAsync(CancellationToken.None); 1063includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: true, CancellationToken.None); 1068var normalPriFixes = await tuple.codeFixService.GetFixesAsync(sourceDocument, testSpan, priorityProvider, CancellationToken.None); 1070var lowPriFixes = await tuple.codeFixService.GetFixesAsync(sourceDocument, testSpan, priorityProvider, CancellationToken.None);

43var simplifiedDocument = Simplifier.ReduceAsync(annotatedDocument, options, CancellationToken.None).Result;

52CancellationToken.None); 86CancellationToken.None); 91var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 93var newRoot = testContext.Service.AddField(root, field, info, CancellationToken.None); 128CancellationToken.None); 173CancellationToken.None); 217CancellationToken.None); 252CancellationToken.None); 298CancellationToken.None); 315var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 317var newSyntax = testContext.Service.AddStatements(oldSyntax, parsedStatements, info, CancellationToken.None); 330var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 333var newMemberSyntax = testContext.Service.AddParameters(oldMemberSyntax, parameterSymbols, info, CancellationToken.None); 366CancellationToken.None); 406CancellationToken.None); 499CancellationToken.None); 528CancellationToken.None); 556var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 558var newNode = codeGenerator.AddAttributes(oldNode, [attributeData], target, info, CancellationToken.None) 575var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 577var newNode = codeGenerator.RemoveAttribute(declarationNode, attribute, info, CancellationToken.None) 597var options = await testContext.Document.GetCodeGenerationOptionsAsync(CancellationToken.None); 601updatedDeclarationNode = codeGenerator.UpdateDeclarationAccessibility(declarationNode, accessibility.Value, info, CancellationToken.None); 605updatedDeclarationNode = codeGenerator.UpdateDeclarationModifiers(declarationNode, modifiers, info, CancellationToken.None); 609updatedDeclarationNode = codeGenerator.UpdateDeclarationType(declarationNode, getType(testContext.SemanticModel), info, CancellationToken.None); 627updatedDeclarationNode = codeGenerator.UpdateDeclarationMembers(declarationNode, allMembers, info, CancellationToken.None); 664testContext.Result = await testContext.Service.AddMembersAsync(solutionContext, (INamedTypeSymbol)destination, members, CancellationToken.None); 668testContext.Result = await testContext.Service.AddNamespaceOrTypeAsync(solutionContext, (INamespaceSymbol)destination, symbol, CancellationToken.None); 976var simplified = Simplifier.ReduceAsync(this.Document, Simplifier.Annotation, simplifierOptions, CancellationToken.None).Result; 977var actual = Formatter.FormatAsync(simplified, Formatter.Annotation, formattingOptions, CancellationToken.None).Result.GetSyntaxRootAsync().Result.ToFullString();

51var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 90var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 111var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); 174var txtRefactorings = await refactoringService.GetRefactoringsAsync(txtAdditionalDocument, TextSpan.FromBounds(0, 0), CancellationToken.None); 182var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None, CancellationToken.None); 184Assert.Empty(txtAdditionalDocument.GetTextSynchronously(CancellationToken.None).ToString()); 185Assert.Equal(refactoring1.Title, changedtxtDocument.GetTextSynchronously(CancellationToken.None).ToString()); 189var logRefactorings = await refactoringService.GetRefactoringsAsync(logAdditionalDocument, TextSpan.FromBounds(0, 0), CancellationToken.None); 213var editorConfigRefactorings = await refactoringService.GetRefactoringsAsync(editorConfig, TextSpan.FromBounds(0, 0), CancellationToken.None); 221var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None, CancellationToken.None); 223Assert.Empty(editorConfig.GetTextSynchronously(CancellationToken.None).ToString()); 224Assert.Equal(refactoring1.Title, changedEditorConfig.GetTextSynchronously(CancellationToken.None).ToString()); 228var globalConfigRefactorings = await refactoringService.GetRefactoringsAsync(globalConfig, TextSpan.FromBounds(0, 0), CancellationToken.None);

741null, service, textView.TextBuffer, textView.Selection.GetSnapshotSpansOnBuffer(textView.TextBuffer), operation, CancellationToken.None);

60AssertItemsEqual(fsc.GetTestAccessor().GetItems("", CancellationToken.None), 71AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"X:\A\", CancellationToken.None), 76AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"X:\B\", CancellationToken.None), 79AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"Z:\", CancellationToken.None), 83AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"Z:", CancellationToken.None), 86AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\", CancellationToken.None), 117AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None), 153AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None), 179AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\\server\share\", CancellationToken.None), 183AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"\\server\share\C\", CancellationToken.None), 218AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"", CancellationToken.None), 227AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"/", CancellationToken.None), 233AssertItemsEqual(fsc.GetTestAccessor().GetItems(@"/B/", CancellationToken.None),

43return helper.GetItems(pathSoFar, CancellationToken.None);

68includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, CancellationToken.None); 185var diagnostics = await service.ForceAnalyzeProjectAsync(document.Project, CancellationToken.None); 219var diagnostics = await service.ForceAnalyzeProjectAsync(document.Project, CancellationToken.None); 259var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None); 342var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None); 391var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None); 472var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None); 559var document = isSourceGenerated ? (await project.GetSourceGeneratedDocumentsAsync(CancellationToken.None)).Single() : project.Documents.Single(); 594var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None); 639cancellationToken: CancellationToken.None); 684var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 706CancellationToken.None); 710var expectedText = additionalDocument.GetTextSynchronously(CancellationToken.None).ToString(); 774logPerformanceInfo: false, getTelemetryInfo: false, cancellationToken: CancellationToken.None); 805var diagnostics = await service.ForceAnalyzeProjectAsync(project, CancellationToken.None);

171var diagnostic = await diagnosticData.ToDiagnosticAsync(document.Project, CancellationToken.None); 206var diagnostic = await diagnosticData.ToDiagnosticAsync(document.Project, CancellationToken.None); 235var document = await project.GetSourceGeneratedDocumentAsync(documentId, CancellationToken.None); 256var diagnostic = await diagnosticData.ToDiagnosticAsync(project, CancellationToken.None); 304var diagnostic = await diagnosticData.ToDiagnosticAsync(firstDocument.Project, CancellationToken.None);

128var syntaxTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None); 141await localService.StartSessionAsync(CancellationToken.None); 153await localService.EnterBreakStateAsync(CancellationToken.None); 171var syntaxTree = solution.GetRequiredDocument(documentId).GetSyntaxTreeSynchronously(CancellationToken.None)!; 218var updates = await localService.GetUpdatesAsync(runningProjects: [project.FilePath], CancellationToken.None); 253var syntaxTree = solution.GetRequiredDocument(documentId).GetSyntaxTreeSynchronously(CancellationToken.None)!; 282updates = await localService.GetUpdatesAsync(runningProjects: [project.FilePath], CancellationToken.None); 320await localService.CommitUpdatesAsync(CancellationToken.None); 329await localService.DiscardUpdatesAsync(CancellationToken.None); 337await localService.EndSessionAsync(CancellationToken.None); 374_ = await document1.GetTextAsync(CancellationToken.None); 378await languageService.StartSessionAsync(CancellationToken.None); 379await languageService.EnterBreakStateAsync(CancellationToken.None); 391Assert.Equal(source1, (await documentState.GetTextAsync(CancellationToken.None)).ToString()); 395var (document, state) = await debuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(document1, CancellationToken.None); 398Assert.Equal(source1, (await document.GetTextAsync(CancellationToken.None)).ToString()); 400await languageService.EndSessionAsync(CancellationToken.None);

56=> (_context, CancellationToken.None);

28solution, reference1, checksum: null, CancellationToken.None); 31solution, reference2, checksum: null, CancellationToken.None); 34Assert.Equal(info1.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None)); 35Assert.Equal(info2.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None)); 48var checksum1 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None); 50solution, reference1, checksum1, CancellationToken.None); 52var checksum2 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None); 54solution, reference2, checksum2, CancellationToken.None); 71var checksum1 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None); 73solution, reference1, checksum1, CancellationToken.None); 76solution, reference2, checksum: null, CancellationToken.None); 80Assert.Equal(info2.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None)); 94solution, reference1, checksum: null, CancellationToken.None); 96var checksum2 = SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference2, CancellationToken.None); 98solution, reference2, checksum2, CancellationToken.None); 101Assert.Equal(info1.Checksum, SymbolTreeInfo.GetMetadataChecksum(solution.Services, reference1, CancellationToken.None));

26var options = await testWorkspace.CurrentSolution.Projects.Single().Documents.Single().GetLineFormattingOptionsAsync(CancellationToken.None); 39var options = await testWorkspace.CurrentSolution.Projects.Single().Documents.Single().GetLineFormattingOptionsAsync(CancellationToken.None); 53var options = await testWorkspace.CurrentSolution.Projects.Single().Documents.Single().GetLineFormattingOptionsAsync(CancellationToken.None);

57var cancellationToken = CancellationToken.None; 88var cancellationToken = CancellationToken.None; 169var docSpan = await actualDocumentSpans[i].TryRehydrateAsync(workspace.CurrentSolution, CancellationToken.None); 215var cancellationToken = CancellationToken.None;

56var response = await testLspServer.ExecuteRequestAsync<TSRequest, int>(TypeScriptHandler.MethodName, request, CancellationToken.None); 80var response = await testLspServer.ExecuteRequestAsync<VSInternalDocumentDiagnosticsParams, VSInternalDiagnosticReport[]>(VSInternalMethods.DocumentPullDiagnosticName, documentPullRequest, CancellationToken.None);

91return _metadataAsSourceService.GetGeneratedFileAsync(Workspace, project, symbol, signaturesOnly, MetadataAsSourceOptions.Default, CancellationToken.None); 103var compilation = await project.GetRequiredCompilationAsync(CancellationToken.None); 132var result = await _metadataAsSourceService.GetGeneratedFileAsync(Workspace, project, symbol, signaturesOnly, MetadataAsSourceOptions.Default, CancellationToken.None); 171compilation = await this.DefaultProject.GetRequiredCompilationAsync(CancellationToken.None); 317var syntaxRoot = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 318var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None);

1882await Formatter.FormatAsync(document, CSharpSyntaxFormattingOptions.Default, CancellationToken.None);

119var storage = await persistentService.GetStorageAsync(SolutionKey.ToSolutionKey(previewWorkspace.CurrentSolution), CancellationToken.None); 168var compilation = project.GetRequiredCompilationAsync(CancellationToken.None).Result; 170var result = compilationWithAnalyzers.GetAnalysisResultAsync(CancellationToken.None).Result;

173document, span, actions.Add, CancellationToken.None); 196var operations = (await codeAction.GetOperationsAsync(CancellationToken.None)).ToArray(); 199await operations[0].TryApplyAsync(this.Workspace, this.Workspace.CurrentSolution, CodeAnalysisProgress.None, CancellationToken.None);

362[], new TextChange(new TextSpan(8, 0), "quux"), triggerLocation: 12, CancellationToken.None).Result; 373[], new TextChange(new TextSpan(4, 4), "bar quux"), triggerLocation: 12, CancellationToken.None).Result; 449var lspSnippetString = await RoslynLSPSnippetConverter.GenerateLSPSnippetAsync(document, cursorPosition!.Value, placeholders, textChange, stringSpan.Start, CancellationToken.None).ConfigureAwait(false);

25var result = await StackTraceAnalyzer.AnalyzeAsync(inputLine, CancellationToken.None); 32var reparsedResult = await StackTraceAnalyzer.AnalyzeAsync(stackFrame.ToString(), CancellationToken.None); 40var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, stackFrame, StackFrameSymbolPart.Method, CancellationToken.None); 47var root = await doc.GetRequiredSyntaxRootAsync(CancellationToken.None); 49var semanticModel = await doc.GetRequiredSemanticModelAsync(CancellationToken.None); 861var result = await StackTraceAnalyzer.AnalyzeAsync(line, CancellationToken.None); 883var result = await StackTraceAnalyzer.AnalyzeAsync(line, CancellationToken.None); 888var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, parsedFrame, StackFrameSymbolPart.Method, CancellationToken.None); 897var result = await StackTraceAnalyzer.AnalyzeAsync(activityLogException, CancellationToken.None); 913var result = await StackTraceAnalyzer.AnalyzeAsync("at System.String.ToLower()", CancellationToken.None); 918var definition = await service.TryFindDefinitionAsync(workspace.CurrentSolution, frame, StackFrameSymbolPart.Method, CancellationToken.None); 951var result = await StackTraceAnalyzer.AnalyzeAsync("at Path.To.Component.M() in C:/path/to/Component.razor:line 5", CancellationToken.None); 990var result = await StackTraceAnalyzer.AnalyzeAsync("at Path.To.Component.M() in Component.razor:line 5", CancellationToken.None);

123var structure = await outliningService.GetBlockStructureAsync(document, options, CancellationToken.None);

657var results = await SymbolFinder.FindDerivedClassesArrayAsync(firstType, solution, transitive: true, ImmutableHashSet.Create(csProject), CancellationToken.None); 662results = await SymbolFinder.FindDerivedClassesArrayAsync(firstType, solution, transitive: true, ImmutableHashSet.Create(otherProject), CancellationToken.None); 768var interfaceMembers = await SymbolFinder.FindImplementedInterfaceMembersArrayAsync(methodSymbol, solution, CancellationToken.None); 798var implementedMembers = await SymbolFinder.FindImplementedInterfaceMembersArrayAsync(namespaceSymbol, solution, CancellationToken.None); 828var sourceDefinition = await SymbolFinder.FindSourceDefinitionAsync(classInSource, solution, CancellationToken.None); 867.Project.Solution.WithFrozenPartialCompilations(CancellationToken.None); 876var sourceDefinition = await SymbolFinder.FindSourceDefinitionAsync(classInSource, solution, CancellationToken.None);

44var semanticModel = await csDocument.GetRequiredSemanticModelAsync(CancellationToken.None); 52var vbCompilation = await vbProject.GetRequiredCompilationAsync(CancellationToken.None); 54var resolved = SymbolKey.ResolveString(methodSymbol.GetSymbolKey().ToString(), vbCompilation, out var failureReason, CancellationToken.None);

65Assert.Equal("Hello, World!", newDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString()); 66Assert.Equal("Hello, World!", newDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString()); 71Assert.Equal("Hello", originalDocumentWithChanges.GetTextSynchronously(CancellationToken.None).ToString()); 72Assert.Equal("Hello", originalDocumentWithChanges.GetLinkedDocuments().Single().GetTextSynchronously(CancellationToken.None).ToString());

174CancellationToken.None).ConfigureAwait(false);

304}, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default); 314}, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);

88var handle = await temporaryStorageService.WriteToTemporaryStorageAsync(text, CancellationToken.None); 91var text2 = await handle.ReadFromTemporaryStorageAsync(CancellationToken.None); 108var handle = await temporaryStorageService.WriteToTemporaryStorageAsync(text, CancellationToken.None); 111var text2 = await handle.ReadFromTemporaryStorageAsync(CancellationToken.None); 121var text = textFactoryService.CreateText(stream, defaultEncoding, SourceHashAlgorithms.Default, CancellationToken.None);

48ClassificationOptions.Default, CancellationToken.None) 96document, New TextSpan(0, text.Length), ClassificationOptions.Default, includeAdditiveSpans:=False, CancellationToken.None) 157document, New TextSpan(0, text.Length), ClassificationOptions.Default, includeAdditiveSpans:=False, CancellationToken.None) 222ClassificationOptions.Default, CancellationToken.None) 323Dim text = Await wrongDocument.GetTextAsync(CancellationToken.None) 327Await classificationService.AddSyntacticClassificationsAsync(wrongDocument, New TextSpan(0, text.Length), result, CancellationToken.None) 328Await classificationService.AddSemanticClassificationsAsync(wrongDocument, New TextSpan(0, text.Length), options:=Nothing, result, CancellationToken.None)

54Assert.Empty(tree.GetDiagnostics(CancellationToken.None)) 58document, hostDocument.CursorPosition.Value, CancellationToken.None) 77Assert.Empty(triggerTree.GetDiagnostics(CancellationToken.None)) 81triggerDocument, triggerHostDocument.CursorPosition.Value, CancellationToken.None)

112document, hostDocument.CursorPosition.Value, CancellationToken.None)

72range:=(Await document.GetSyntaxRootAsync()).FullSpan, DiagnosticKind.All, CancellationToken.None) 80CancellationToken.None) 95CancellationToken.None) 104CancellationToken.None) 142range:=(Await document.GetSyntaxRootAsync()).FullSpan, DiagnosticKind.All, CancellationToken.None) 150CancellationToken.None) 165CancellationToken.None) 291Function(d) d.ToDiagnosticAsync(document.Project, CancellationToken.None).Result) 296document, Text.TextSpan.FromBounds(0, 0), New DefaultCodeActionRequestPriorityProvider(), CancellationToken.None)

83Dim operations = Await codeAction.GetOperationsAsync(CancellationToken.None) 87operation.Apply(workspace, CancellationToken.None) 168Dim context = New CodeFixContext(document, diagnostic, Sub(a, d) fixes.Add(New CodeFix(document.Project, a, d)), CancellationToken.None) 206Dim operations = Await codeAction.GetOperationsAsync(CancellationToken.None) 225Dim operations = Await codeAction.GetOperationsAsync(CancellationToken.None)

48Dim operations = codeAction.GetOperationsAsync(CancellationToken.None).Result

270includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None).Result)

65Return Await diagnosticService.GetDiagnosticsForSpanAsync(document, range, diagnosticKind, CancellationToken.None) 538includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) 609includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) 808includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) 821Dim actualLocation = withDocumentLocationDiagnostic.ToDiagnosticAsync(project, CancellationToken.None).Result.Location 958includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)). 1053includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) 2145project, CancellationToken.None) 2155includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None) 2189Dim root = Await document.GetSyntaxRootAsync(CancellationToken.None) 2242includeLocalDocumentDiagnostics:=True, includeNonLocalDocumentDiagnostics:=True, CancellationToken.None)

30Dim cleanupOptions = Await document.GetCodeCleanupOptionsAsync(CancellationToken.None) 43document = Await Simplifier.ReduceAsync(document, Simplifier.Annotation, cleanupOptions.SimplifierOptions, CancellationToken.None) 49document = Await Formatter.FormatAsync(document, cleanupOptions.FormattingOptions, CancellationToken.None)

22Dim namedTypeSymbol = semanticModel.GetEnclosingNamedType(cursorPosition, CancellationToken.None)

81Return (_context, CancellationToken.None)

75Await workspace.CurrentSolution.GetSourceGeneratedDocumentAsync(cursorDocument.Id, CancellationToken.None)) 81Await findRefsService.FindReferencesAsync(context, startDocument, cursorPosition, classificationOptions, CancellationToken.None) 249Await workspace.CurrentSolution.GetSourceGeneratedDocumentAsync(cursorDocument.Id, CancellationToken.None)) 263documents:=scope, options, CancellationToken.None)) 299Await workspace.CurrentSolution.GetSourceGeneratedDocumentAsync(doc.Id, CancellationToken.None))

21Await gotoBaseService.FindBasesAsync(context, document, position, options, CancellationToken.None)

48document, cursorPosition, CancellationToken.None) 52Await defLocation.NavigateToAsync(NavigationOptions.Default, CancellationToken.None)

25Dim document = Await solution.GetRequiredDocumentAsync(documentWithCursor.Id, includeSourceGenerated:=True, CancellationToken.None)

21Await findUsagesService.FindImplementationsAsync(context, document, position, options, CancellationToken.None).ConfigureAwait(False)

32document, span, options, displayOptions, displayAllOverride:=False, CancellationToken.None) 92document, span, options, displayOptions, displayAllOverride:=ephemeral, CancellationToken.None)

53ClassificationOptions.Default, LineFormattingOptions.Default, navigationActionFactory, CancellationToken.None) 69Dim codeAnalysisQuickInfoItem = Await quickInfoService.GetQuickInfoAsync(document, cursorPosition, SymbolDescriptionOptions.Default, CancellationToken.None).ConfigureAwait(False) 87navigationActionFactory, CancellationToken.None)

6982Await ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(document.Project, CancellationToken.None) 6990Await ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(document.Project, CancellationToken.None) 10897Dim computedItems = (Await state.GetCompletionSession()).GetComputedItems(CancellationToken.None)

40Dim items = session.GetComputedItems(CancellationToken.None).Items 64Dim items = session.GetComputedItems(CancellationToken.None).Items 102Dim sourceText = document.GetTextSynchronously(CancellationToken.None)

119Return source.GetNavigableSymbolAsync(triggerSpan, CancellationToken.None)

99Dim newDocument = Await VisualBasicEditorNavigationBarItemService.GetGeneratedDocumentAsync(document, generateCodeItem, CancellationToken.None)

338CancellationToken.None,

47csharpDocument, position, ImmutableHashSet.Create(csharpDocument, vbDocument), options, CancellationToken.None)

1282CancellationToken.None) 1297Await actions.First().NestedActions.First().GetOperationsAsync(CancellationToken.None), 1300CancellationToken.None)

93Dim symbol = RenameUtilities.TryGetRenamableSymbolAsync(document, cursorPosition, CancellationToken.None).Result 137solution, symbol, renameOptions, CancellationToken.None).GetAwaiter().GetResult() 139Return locations.ResolveConflictsAsync(symbol, renameTo, nonConflictSymbolKeys:=Nothing, CancellationToken.None).GetAwaiter().GetResult() 146nonConflictSymbolKeys:=Nothing, CancellationToken.None).GetAwaiter().GetResult() 275Let spanText = document.GetTextSynchronously(CancellationToken.None).ToString(location.ConflictCheckSpan)

47Return DirectCast(renameService.StartInlineSession(sessionInfo.document, sessionInfo.textSpan, CancellationToken.None).Session, InlineRenameSession) 54Dim result = renameService.StartInlineSession(sessionInfo.document, sessionInfo.textSpan, CancellationToken.None) 63Dim result = renameService.StartInlineSession(sessionInfo.document, sessionInfo.textSpan, CancellationToken.None)

29Dim simplifiedDocument = Await Simplifier.ReduceAsync(annotatedDocument, CSharpSimplifierOptions.Default, CancellationToken.None)

43Dim newSolution = Await syncService.SyncNamespacesAsync(ImmutableArray.Create(project), CodeAnalysisProgress.None, CancellationToken.None) 79Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None) 136Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None) 190Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None) 255Dim newSolution = Await syncService.SyncNamespacesAsync(projects, CodeAnalysisProgress.None, CancellationToken.None)

66Dim mappedType = Await SymbolFinder.FindSourceDefinitionAsync(fieldType, snapshot, CancellationToken.None)

232CancellationToken.None, 242CancellationToken.None,

232CancellationToken.None, 242CancellationToken.None,

232CancellationToken.None, 242CancellationToken.None,

68=> GetDesiredIndentation(line, CancellationToken.None);

72CancellationToken.None)));

32disposalToken: CancellationToken.None);

26action(hpc, source, CancellationToken.None);

412cancellationToken: CancellationToken.None);

47CancellationToken.None);

33_ = ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(document.Project, CancellationToken.None);

22listenerProvider, ExtensionMethodImportCompletionHelper.BatchUpdateCacheAsync, CancellationToken.None);

18listenerProvider, AbstractTypeImportCompletionService.BatchUpdateCacheAsync, CancellationToken.None);

201cancellationToken = CancellationToken.None; 224cancellationToken = CancellationToken.None;

201_lowPriorityProcessor.ProcessProjectAsync(analyzers, item, CancellationToken.None).Wait();

380_normalPriorityProcessor.ProcessDocumentAsync(analyzers, item, CancellationToken.None).Wait();

62CancellationToken.None, 289using (gate.DisposableWait(CancellationToken.None)) 352CancellationToken.None,

26=> this.TryNavigateToPosition(workspace, documentId, position, virtualSpace, options, CancellationToken.None);

37Debug.Assert(document.GetRequiredSyntaxRootSynchronously(CancellationToken.None) == root);

692_service._reportAndSwallowExceptionUnlessCanceled(new FormatException($"Database element invalid. Missing '{ContentAttributeName}' attribute"), CancellationToken.None); 711_service._reportAndSwallowExceptionUnlessCanceled(new FormatException($"Checksum mismatch: expected != actual. {expectedChecksum} != {actualChecksum}"), CancellationToken.None);

102CancellationToken.None); 191var result = Analyzer.AnalyzeDocumentAsync(newDocument.Id, oldProject, newProject, lazyOldActiveStatementMap, newActiveStatementSpans, lazyCapabilities, log, CancellationToken.None).Result; 278EditSession.MergePartialEdits(oldProject.GetCompilationAsync().Result!, newProject.GetCompilationAsync().Result!, allEdits, out var mergedEdits, out _, CancellationToken.None);

181CancellationToken.None); 231var result = await session.EmitSolutionUpdateAsync(solution, runningProjects, activeStatementSpanProvider ?? s_noActiveSpans, CancellationToken.None); 245var results = await session.EmitSolutionUpdateAsync(solution, runningProjects, activeStatementSpanProvider ?? s_noActiveSpans, CancellationToken.None); 324project.Documents.Select(d => (d.GetTextSynchronously(CancellationToken.None), d.FilePath ?? throw ExceptionUtilities.UnexpectedValue(null))),

43}, CancellationToken.None);

36var metadataReferences = await referenceAssemblies.ResolveAsync(LanguageName, CancellationToken.None); 64var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None); 65var syntaxContext = syntaxContextService.CreateContext(document, semanticModel, snippetRequestPosition, CancellationToken.None); 68var isValidSnippetLocation = snippetProvider.IsValidSnippetLocation(snippetContext, CancellationToken.None); 71var snippetChange = await snippetProvider.GetSnippetChangeAsync(document, snippetRequestPosition, CancellationToken.None); 126var metadataReferences = await referenceAssemblies.ResolveAsync(LanguageName, CancellationToken.None); 141var semanticModel = await document.GetRequiredSemanticModelAsync(CancellationToken.None); 142var syntaxContext = syntaxContextService.CreateContext(document, semanticModel, snippetRequestPosition, CancellationToken.None); 145var isValidSnippetLocation = snippetProvider.IsValidSnippetLocation(snippetContext, CancellationToken.None);

27var root = await document.GetRequiredSyntaxRootAsync(CancellationToken.None); 35var items = service.GetItems(document.Id, node, CancellationToken.None);

145var oldSpans = await map.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None); 197var oldSpans = await map.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None);

69var compileTimeDocument = await CompileTimeSolutionProvider.TryGetCompileTimeDocumentAsync(designTimeDocument, compileTimeSolution, CancellationToken.None, sourceGeneratedPathPrefix);

139var sessionId = await service.StartDebuggingSessionAsync(solution, _debuggerService, NullPdbMatchingSourceTextProvider.Instance, captureMatchingDocuments, captureAllDocuments, reportDiagnostics: true, CancellationToken.None); 174var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None); 181diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 218var diagnostics2 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 249var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None); 262diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 292var diagnostics1 = await service.GetDocumentDiagnosticsAsync(generatedDocument, s_noActiveSpans, CancellationToken.None); 324var diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 422var sessionId = await service.StartDebuggingSessionAsync(solution, _debuggerService, NullPdbMatchingSourceTextProvider.Instance, captureMatchingDocuments: openDocumentIds, captureAllMatchingDocuments: false, reportDiagnostics: true, CancellationToken.None); 448var activeStatementMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None); 452var asSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [designTimeOnlyDocumentId], CancellationToken.None); 456Assert.Empty(await service.GetDocumentDiagnosticsAsync(designTimeOnlyDocument2, s_noActiveSpans, CancellationToken.None)); 514var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 594var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 642var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 704var diagnostics2 = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None); 793var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(document2Id), s_noActiveSpans, CancellationToken.None); 952var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1017var (document, state) = await debuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(solution.GetRequiredDocument(documentId), CancellationToken.None); 1049var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1121var diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1128diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1135diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1153diagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1192var docDiagnostics = await service.GetDocumentDiagnosticsAsync(generatedDocument, s_noActiveSpans, CancellationToken.None); 1242var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1257docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1270docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1341var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1384var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1398docDiagnostics = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1459var docDiagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None); 1498Assert.Empty(await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None)); 1504Assert.Empty(await service.GetDocumentDiagnosticsAsync(solution.GetRequiredDocument(documentId), s_noActiveSpans, CancellationToken.None)); 1551var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1591var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 1658Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1660Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathCommon, CancellationToken.None)); 1661Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathB, CancellationToken.None)); 1662Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathC, CancellationToken.None)); 1663Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: "NonexistentFile.cs", CancellationToken.None)); 1675Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1678Assert.True(await EditSession.HasChangesAsync(solution, solution.RemoveProject(projectD.Id), CancellationToken.None)); 1686Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1689Assert.False(await EditSession.HasChangesAsync(solution, oldSolution, CancellationToken.None)); 1761Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1762Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); 1765Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, generatedDocument.FilePath, CancellationToken.None)); 1771await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); 1774await EditSession.GetDocumentDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), documentDifferences, diagnostics, CancellationToken.None); 1795Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1796Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); 1802await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); 1804await EditSession.GetDocumentDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), documentDifferences, diagnostics, CancellationToken.None); 1823Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1824Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); 1827await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); 1829await EditSession.GetDocumentDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), documentDifferences, diagnostics, CancellationToken.None); 1849Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1850Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); 1855await EditSession.GetChangedDocumentsAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); 1857await EditSession.GetDocumentDifferencesAsync(log, oldSolution.GetProject(projectId), solution.GetProject(projectId), documentDifferences, diagnostics, CancellationToken.None); 1910var generatedDocuments = await project.Solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, CancellationToken.None); 1912var generatedText = generatedDocuments.States.Single().Value.GetTextSynchronously(CancellationToken.None).ToString(); 1916var generatorDiagnostics = await solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, CancellationToken.None); 1934Assert.True(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 1937AssertEx.Empty(await EditSession.GetChangedDocumentsAsync(log, oldProject, project, CancellationToken.None).ToImmutableArrayAsync(CancellationToken.None)); 1940await EditSession.GetDocumentDifferencesAsync(log, oldProject, project, documentDiffences, diagnostics, CancellationToken.None); 1947generatedDocuments = await solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, CancellationToken.None); 1950generatorDiagnostics = await solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, CancellationToken.None); 2010var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentA1.Id, documentB2.Id], CancellationToken.None); 2020var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(documentB2, (_, _, _) => new(trackedActiveSpans), CancellationToken.None); 2025var diagnostics = await service.GetDocumentDiagnosticsAsync(documentB2, s_noActiveSpans, CancellationToken.None); 2066var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2074diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2094diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2103diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2119diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2216var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 2248var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 2415var diagnostics = await service.GetDocumentDiagnosticsAsync(document3, s_noActiveSpans, CancellationToken.None); 2432var (doc, state) = await debuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(currentDocument, CancellationToken.None); 2498var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None); 2555var diagnostics = await service.GetDocumentDiagnosticsAsync(document3, s_noActiveSpans, CancellationToken.None); 2588var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 2923var docDiagnostics = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None); 3014var diagnostics = await service.GetDocumentDiagnosticsAsync(documentB, s_noActiveSpans, CancellationToken.None); 3026var result = await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects, s_noActiveSpans, CancellationToken.None); 3070_ = await solution.Projects.Single().GetCompilationAsync(CancellationToken.None); 3127_ = await solution.Projects.Single().GetCompilationAsync(CancellationToken.None); 3424var diagnostics1 = await service.GetDocumentDiagnosticsAsync(document2, s_noActiveSpans, CancellationToken.None); 3467var diagnostics = await service.GetDocumentDiagnosticsAsync(solution.GetDocument(documentId), s_noActiveSpans, CancellationToken.None); 3878var sourceTextV1 = document1.GetTextSynchronously(CancellationToken.None); 3891Assert.True((await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document1.Id], CancellationToken.None)).IsDefault); 3914var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document1.Id], CancellationToken.None); 3923var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document1, (_, _, _) => new(trackedActiveSpans1), CancellationToken.None); 3935currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document2, (_, _, _) => new(trackedActiveSpans2), CancellationToken.None); 3958var sourceTextV1 = await document1.GetTextAsync(CancellationToken.None); 3987var baseSpans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single(); 3999var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document2, (_, _, _) => ValueTaskFactory.FromResult(baseSpans), CancellationToken.None); 4035var currentSpans = await debuggingSession.GetAdjustedActiveStatementSpansAsync(document, s_noActiveSpans, CancellationToken.None); 4038var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None); 4044baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None); 4103var baseActiveStatementsMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 4134var spans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [doc1.Id, doc2.Id, docId3, docId4, docId5], CancellationToken.None); 4207var baseActiveStatementMap = await debuggingSession.EditSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 4226var baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None); 4233baseSpans = await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [document.Id], CancellationToken.None); 4391var docDiagnostics = await service.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None); 4409docDiagnostics = await service.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None); 4527var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single(); 4616var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single(); 4642spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single(); 4651var diagnostics = await service.GetDocumentDiagnosticsAsync(document1, s_noActiveSpans, CancellationToken.None); 4740var spans = (await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [documentId], CancellationToken.None)).Single(); 4868CancellationToken.None); 4872var result1 = await encService.EmitSolutionUpdateAsync(sessionId, solution1, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None); 4879var result2 = await encService.EmitSolutionUpdateAsync(sessionId, solution2, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None); 4902await Assert.ThrowsAsync<ObjectDisposedException>(async () => await debuggingSession.EmitSolutionUpdateAsync(solution, runningProjects: ImmutableDictionary<ProjectId, RunningProjectInfo>.Empty, s_noActiveSpans, CancellationToken.None)); 4909Assert.Empty(await debuggingSession.GetDocumentDiagnosticsAsync(document, s_noActiveSpans, CancellationToken.None)); 4910Assert.Empty(await debuggingSession.GetAdjustedActiveStatementSpansAsync(document, s_noActiveSpans, CancellationToken.None)); 4911Assert.True((await debuggingSession.GetBaseActiveStatementSpansAsync(solution, [], CancellationToken.None)).IsDefault);

189var baseActiveStatementsMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 235var oldActiveStatements1 = await baseActiveStatementsMap.GetOldActiveStatementsAsync(analyzer, document1, CancellationToken.None).ConfigureAwait(false); 243var oldActiveStatements2 = await baseActiveStatementsMap.GetOldActiveStatementsAsync(analyzer, document2, CancellationToken.None).ConfigureAwait(false); 353var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 368var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false); 533var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 551var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false); 674var baseActiveStatementMap = await editSession.BaseActiveStatements.GetValueAsync(CancellationToken.None).ConfigureAwait(false); 703var oldActiveStatements = await baseActiveStatementMap.GetOldActiveStatementsAsync(analyzer, document, CancellationToken.None).ConfigureAwait(false);

80var tree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None);

90var syntaxTree = await document.GetRequiredSyntaxTreeAsync(CancellationToken.None); 151CancellationToken.None); 162await sessionProxy.BreakStateOrCapabilitiesChangedAsync(inBreakState: true, CancellationToken.None); 164var activeStatement = (await remoteDebuggeeModuleMetadataProvider!.GetActiveStatementsAsync(CancellationToken.None)).Single(); 169var availability = await remoteDebuggeeModuleMetadataProvider!.GetAvailabilityAsync(moduleId1, CancellationToken.None); 201var syntaxTree = solution.GetRequiredDocument(documentId).GetSyntaxTreeSynchronously(CancellationToken.None)!; 222var results = await sessionProxy.EmitSolutionUpdateAsync(localWorkspace.CurrentSolution, runningProjects1, activeStatementSpanProvider, CancellationToken.None); 247await sessionProxy.CommitSolutionUpdateAsync(CancellationToken.None); 253await sessionProxy.DiscardSolutionUpdateAsync(CancellationToken.None); 266var baseActiveSpans = await sessionProxy.GetBaseActiveStatementSpansAsync(localWorkspace.CurrentSolution, [documentId, inProcOnlyDocumentId], CancellationToken.None); 274AssertEx.Equal(activeSpans1, activeStatementSpanProvider(documentId, "test.cs", CancellationToken.None).AsTask().Result); 278Assert.Empty(await sessionProxy.GetAdjustedActiveStatementSpansAsync(inProcOnlyDocument, activeStatementSpanProvider, CancellationToken.None)); 280var documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document, activeStatementSpanProvider, CancellationToken.None); 287documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document, activeStatementSpanProvider, CancellationToken.None); 294Assert.Empty(await proxy.GetDocumentDiagnosticsAsync(inProcOnlyDocument, activeStatementSpanProvider, CancellationToken.None)); 295Assert.Equal(diagnostic.GetMessage(), (await proxy.GetDocumentDiagnosticsAsync(document, activeStatementSpanProvider, CancellationToken.None)).Single().Message); 299await sessionProxy.EndDebuggingSessionAsync(CancellationToken.None);

48await hotReload.StartSessionAsync(solution, ["Baseline", "AddDefinitionToExistingType", "NewTypeDefinition"], CancellationToken.None); 61var result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None); 68result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None); 78result = await hotReload.EmitSolutionUpdateAsync(solution, commitUpdates: true, CancellationToken.None);

140var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(a, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 176var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 218var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 254var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 296var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 338var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(n, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 391var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(n, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 445var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 485var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(symbol, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 525var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 567var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 625var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 671var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(c, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 711var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(tuple, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 773var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(tuple, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 829var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(type, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 883var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(type, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 943var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 987var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1042var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(m, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1094var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1158var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(g, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1215var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(g, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1270var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1350var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1409var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(p, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1461var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(f, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1528var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(x, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None); 1599var item = await DefinitionItemFactory.ToClassifiedDefinitionItemAsync(r, classificationOptions, solution, searchOptions, isPrimary: true, includeHiddenLocations: true, CancellationToken.None);

757? script.RunAsync(serviceState.Globals, catchException: e => true, cancellationToken: CancellationToken.None) 758: script.RunFromAsync(state, catchException: e => true, cancellationToken: CancellationToken.None);

232CancellationToken.None, 242CancellationToken.None,

274using (TakeLock(CancellationToken.None)) 297CompleteWithTask(Task.FromException<T>(ex), CancellationToken.None); 302CompleteWithTask(Task.FromResult(result), CancellationToken.None); 419using (TakeLock(CancellationToken.None)) 509using (TakeLock(CancellationToken.None))

260await _changeWatcher._clientLanguageServerManager.SendRequestAsync("client/unregisterCapability", unregistrationParams, CancellationToken.None); 267}, CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default).Unwrap().ReportNonFatalErrorAsync().CompletesAsyncOperation(asyncToken);

118CancellationToken.None); // TODO: do we need to introduce a shutdown cancellation token for this? 382using (await _gate.DisposableWaitAsync(CancellationToken.None)) 405using (await _gate.DisposableWaitAsync(CancellationToken.None)) 422using (await _gate.DisposableWaitAsync(CancellationToken.None))

61var (_, projects) = await SolutionFileReader.ReadSolutionFileAsync(solutionFilePath, DiagnosticReportingMode.Throw, CancellationToken.None);

54CancellationToken.None); // TODO: do we need to introduce a shutdown cancellation token for this? 63miscellaneousFilesWorkspace, fileChangeWatcher, static (_, _) => Task.CompletedTask, _ => { }, CancellationToken.None);

126var disposableBatchScope = await _projectSystemProject.CreateBatchScopeAsync(CancellationToken.None).ConfigureAwait(false);

49await languageServerManager.SendNotificationAsync(ProjectInitializationCompleteName, CancellationToken.None);

58await workspaceProject.SetBuildSystemPropertiesAsync(creationInfo.BuildSystemProperties, CancellationToken.None);

84}, CancellationToken.None);

36return await parser.Parse(args).InvokeAsync(CancellationToken.None); 87await Task.Delay(100, CancellationToken.None);

21return AttachDebugger(pid, CancellationToken.None);

44var cancellationToken = CancellationToken.None;