Solution

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (2)

49var services = _document.Project.Solution.Services; 68return Task.FromResult<Solution?>(constructorDocument.WithSyntaxRoot(newRoot).Project.Solution);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (2)

38if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 185priorDocument.Project.Solution, CodeAnalysisProgress.None, cancellationToken).ConfigureAwait(false);

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

118var editor = new SyntaxEditor(syntaxRoot, document.Project.Solution.Services);

AddImport\AbstractAddImportCodeFixProvider.cs (1)

58var services = document.Project.Solution.Services;

AddImport\AbstractAddImportFeatureService.cs (7)

73document.Project.Solution, 146var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 147var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count)); 168=> project.Solution.WorkspaceKind is WorkspaceKind.Host or WorkspaceKind.RemoteWorkspace; 327var solution = project.Solution; 457var solution = project.Solution; 547document.Project.Solution,

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (2)

47var operation = new ApplyChangesOperation(newProject.Solution); 102return new ApplyChangesOperation(newProject.Solution);

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (2)

57this.OriginalDocument.Project.Solution, cancellationToken).ConfigureAwait(false)); 73return updatedDocument.Project.Solution;

AddImport\CodeActions\MetadataSymbolReferenceCodeAction.cs (2)

29var projectWithReference = project.Solution.GetRequiredProject(FixData.PortableExecutableReferenceProjectId); 34return Task.FromResult<CodeActionOperation?>(new ApplyChangesOperation(project.AddMetadataReference(reference).Solution));

AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs (1)

46var applyOperation = new ApplyChangesOperation(projectWithAddedReference.Solution);

AddImport\CodeActions\SymbolReference.SymbolReferenceCodeAction.cs (1)

58return updatedProject ?? new ApplyChangesOperation(updatedDocument.Project.Solution);

AddImport\SearchScopes\MetadataSymbolsSearchScope.cs (1)

38var service = _assemblyProject.Solution.Services.GetRequiredService<ISymbolTreeInfoCacheService>();

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (1)

32var service = _project.Solution.Services.GetRequiredService<ISymbolTreeInfoCacheService>();

AddMissingReference\AddMissingReferenceCodeAction.cs (4)

31var dependencyGraph = project.Solution.GetProjectDependencyGraph(); 52var candidateProject = project.Solution.GetRequiredProject(candidateProjectId); 81new ApplyChangesOperation(_project.AddProjectReference(_projectReferenceToAdd).Solution))); 86var factoryService = _project.Solution.Services.GetRequiredService<IAddMetadataReferenceCodeActionOperationFactoryWorkspaceService>();

AddPackage\AbstractAddPackageCodeFixProvider.cs (1)

35var workspaceServices = document.Project.Solution.Services;

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

52_document.Project.Solution, packageName, versionOpt).ToList();

AddPackage\ParentInstallPackageCodeAction.cs (1)

71installerService ??= document.Project.Solution.Services.GetService<IPackageInstallerService>();

ChangeSignature\AbstractChangeSignatureService.cs (3)

110symbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false) ?? symbol; 161var solution = document.Project.Solution; 409doc.Project.Solution.Services,

ChangeSignature\ChangeSignatureAnalyzedContext.cs (1)

19public Solution Solution => Document.Project.Solution;

CodeFixes\Configuration\ConfigurationUpdater.cs (8)

258return currentProject.Solution; 267return _project.Solution; 270var solution = editorConfigDocument.Project.Solution; 294if (_project.Solution?.FilePath == null) 304var currentSolution = _project.Solution; 305foreach (var projectId in _project.Solution.ProjectIds) 314currentSolution = addedAnalyzerConfigDocument.Project.Solution; 336var newSolution = project.Solution.AddAnalyzerConfigDocuments([documentInfo]);

CodeFixes\Service\CodeFixService.cs (12)

CodeFixes\Service\CodeFixService.FixAllDiagnosticProvider.cs (4)

46var service = document.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 57var service = document.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 69var service = project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 78var service = project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>();

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.AbstractGlobalSuppressMessageCodeAction.cs (1)

39new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageCodeAction.cs (1)

27var services = suppressionsDoc.Project.Solution.Services;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.GlobalSuppressMessageFixAllCodeAction.cs (5)

73var currentSolution = triggerDocument.Project.Solution; 88currentSolution = newDocument.Project.Solution; 102var currentSolution = triggerProject.Solution; 117currentSolution = newDocument.Project.Solution; 131var services = suppressionsDoc.Project.Solution.Services;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.PragmaWarningCodeAction.cs (1)

85=> Formatter.Format(node, _document.Project.Solution.Services, _options, cancellationToken);

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (1)

115var oldSolution = fixAllState.Project.Solution;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Attribute.cs (2)

67return _project.Solution; 72return editor.GetChangedDocument().Project.Solution;

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction_Pragma.cs (1)

221=> Formatter.Format(node, _document.Project.Solution.Services, _options, cancellationToken);

CodeFixesAndRefactorings\AbstractFixAllCodeAction.cs (2)

57var service = FixAllState.Project.Solution.Services.GetRequiredService<IFixAllGetFixesService>(); 71var service = FixAllState.Project.Solution.Services.GetRequiredService<IFixAllGetFixesService>();

CodeFixesAndRefactorings\AbstractFixAllGetFixesService.cs (2)

60var workspace = fixAllState.Project.Solution.Workspace; 84fixAllState.Project.Solution,

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (6)

39var solution = document.Project.Solution; 79var solution = document.Project.Solution; 154var services = document.Project.Solution.Services; 202document.Project.Solution, progressTracker, cancellationToken).ConfigureAwait(false); 206newSolution = document.Project.Solution; 220var textDiffingService = document.Project.Solution.Services.GetRequiredService<IDocumentTextDifferencingService>();

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsRefactoringProvider.cs (1)

26var services = document.Project.Solution.Workspace.Services.HostServices as IMefHostExportProvider;

CodeRefactorings\CodeRefactoringService.cs (2)

107if (document.Project.Solution.WorkspaceKind == WorkspaceKind.Interactive) 245var extensionManager = textDocument.Project.Solution.Services.GetRequiredService<IExtensionManager>();

CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs (1)

36var solution = document.Project.Solution;

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

60return document.Project.Solution; 67return modifiedSolution ?? document.Project.Solution;

CodeRefactorings\MoveType\AbstractMoveTypeService.MoveTypeEditor.cs (3)

66var solutionWithNewDocument = documentWithMovedType.Project.Solution; 159var solutionWithNewDocument = projectToBeUpdated.Solution.AddDocument( 246return updatedDocument.Project.Solution;

CodeRefactorings\MoveType\AbstractMoveTypeService.MoveTypeNamespaceScopeEditor.cs (1)

83return changedDocument.Project.Solution;

CodeRefactorings\MoveType\AbstractMoveTypeService.RenameFileEditor.cs (1)

33SemanticDocument.Project.Solution.WithDocumentName(SemanticDocument.Document.Id, FileName));

CodeRefactorings\MoveType\AbstractMoveTypeService.RenameTypeEditor.cs (1)

29var solution = SemanticDocument.Project.Solution;

CodeRefactorings\MoveType\MoveTypeCodeRefactoringProvider.cs (1)

21if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (6)

144var solution = document.Project.Solution; 201var solution = document.Project.Solution; 349var solution = document.Project.Solution; 471var solutionWithChangedNamespace = documentWithNewNamespace.Project.Solution; 545symbol, document.Project.Solution, progress, documents: null, 624var services = documentWithAddedImports.Project.Solution.Services;

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.cs (1)

35if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles ||

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.MoveFileCodeAction.cs (1)

40var solution = _state.Document.Project.Solution;

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.State.cs (1)

171var solution = document.Project.Solution;

Completion\CompletionOptions.cs (1)

77var solution = document.Project.Solution;

Completion\CompletionProvider.cs (1)

58=> ShouldTriggerCompletion(document.Project.Services, await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false), caretPosition, trigger, options, document.Project.Solution.Options);

Completion\CompletionService.cs (3)

107var passThroughOptions = options ?? document?.Project.Solution.Options ?? OptionSet.Empty; 213var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 244var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\CompletionService.ProviderManager.cs (1)

99if (project is null || project.Solution.WorkspaceKind == WorkspaceKind.Interactive)

Completion\CompletionService_GetCompletions.cs (3)

47var passThroughOptions = options ?? document.Project.Solution.Options; 153var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 327var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (2)

137foreach (var project in context.Document.Project.Solution.Projects) 272var project = document.Project.Solution.GetRequiredProject(projectId);

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)

141document.Project.Solution,

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

22var solution = originatingDocument.Project.Solution;

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (2)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

264supportedPlatformData = new SupportedPlatformData(completionContext.Document.Project.Solution, invalidProjects.ToImmutable(), totalProjects); 413var solution = document.Project.Solution;

Completion\Providers\CompletionUtilities.cs (2)

41if (solution is null || project.Solution.SolutionStateContentVersion > solution.SolutionStateContentVersion) 43solution = project.Solution;

Completion\Providers\ImportCompletionProvider\AbstractImportCompletionProvider.cs (1)

216document.Project.Solution.Services.GetRequiredService<IDocumentSupportsFeatureService>().SupportsRefactorings(document);

Completion\Providers\ImportCompletionProvider\AbstractTypeImportCompletionService.cs (1)

92var solution = currentProject.Solution;

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.SymbolComputer.cs (5)

60=> project.Solution.Services.GetRequiredService<IImportCompletionCacheService<ExtensionMethodImportCompletionCacheEntry, object>>(); 78await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false); 126var graph = project.Solution.GetProjectDependencyGraph(); 128return [.. relevantProjectIds.Select(project.Solution.GetRequiredProject).Where(p => p.SupportsCompilation)]; 190_originatingDocument.Project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false);

Completion\Providers\ImportCompletionProvider\ImportCompletionItem.cs (1)

147document.Project.Solution.Services,

Completion\Providers\SymbolCompletionItem.cs (6)

149var linkedDoc = document.Project.Solution.GetRequiredDocument(id); 200var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 204var services = document.Project.Solution.Services; 215return document.Project.Solution.GetRequiredDocument(contextId); 392var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 396return await CommonCompletionUtilities.CreateDescriptionAsync(document.Project.Solution.Services, semanticModel, position, symbols, options, supportedPlatforms, cancellationToken).ConfigureAwait(false);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

94var editor = new SyntaxEditor(root, document.Project.Solution.Services);

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

419var services = document.Project.Solution.Services;

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (1)

37if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (1)

151var editor = new SyntaxEditor(converter.ForEachInfo.SemanticModel.SyntaxTree.GetRoot(cancellationToken), document.Project.Solution.Services);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (7)

193var hostServices = document.Project.Solution.Services 223var solution = document.Project.Solution; 259return document.WithSyntaxRoot(newRoot).Project.Solution; 438var solution = startingProject.Solution; 524var solution = startingDocument.Project.Solution; 586var currentSolution = startingDocument.Project.Solution; 607currentSolution = updatedDocument.Project.Solution;

Copilot\CopilotChangeAnalysisUtilities.cs (1)

60var changeAnalysisService = document.Project.Solution.Services.GetRequiredService<ICopilotChangeAnalysisService>();

Copilot\ICopilotChangeAnalysisService.cs (3)

120var projectConeCount = 1 + document.Project.Solution 214var diagnosticAnalyzerService = newDocument.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 322args: (@this: this, newDocument.Project.Solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName,

DesignerAttribute\DesignerAttributeDiscoveryService.cs (2)

64var solutionServices = project.Solution.Services; 65var solutionKey = SolutionKey.ToSolutionKey(project.Solution);

Diagnostics\CodeAnalysisDiagnosticAnalyzerService.cs (1)

89Contract.ThrowIfFalse(project.Solution.Workspace == _workspace);

Diagnostics\DiagnosticAnalyzerExtensions.cs (2)

53var diagnosticAnalyzerService = project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 55project.Solution, project.Id, analyzerReference, project.Language, cancellationToken);

Diagnostics\Service\DiagnosticAnalyzerService.HostAnalyzerInfo.cs (2)

107var solution = project.Solution; 199return GetFeaturesAnalyzerReferenceIds(project.Solution.SolutionState.Analyzers);

Diagnostics\Service\DiagnosticAnalyzerService.ProjectStates.cs (1)

58var solutionAnalyzers = project.Solution.SolutionState.Analyzers;

Diagnostics\Service\DiagnosticAnalyzerService_ComputeDiagnosticAnalysisResults.cs (1)

63var compilerAnalyzer = project.Solution.SolutionState.Analyzers.GetCompilerDiagnosticAnalyzer(project.Language);

Diagnostics\Service\DiagnosticAnalyzerService_CoreAnalyze.cs (2)

50var skippedAnalyzersInfo = project.Solution.SolutionState.Analyzers.GetSkippedAnalyzersInfo(project.State, _analyzerInfoCache); 88var service = project.Solution.Services.GetService<IPerformanceTrackerService>();

Diagnostics\Service\DiagnosticAnalyzerService_ForceAnalyzeProject.cs (1)

76var solutionState = project.Solution.SolutionState;

Diagnostics\Service\DiagnosticAnalyzerService_RemoteOrLocalDispatcher.cs (1)

100return project.Solution.SolutionState.Analyzers.GetDiagnosticDescriptorsPerReference(this._analyzerInfoCache, project);

Diagnostics\Service\DocumentAnalysisExecutor.cs (1)

355var diagnosticSpanMappingService = textDocument.Project.Solution.Services.GetService<IWorkspaceVenusSpanMappingService>();

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (1)

195foreach (var documentId in project.Solution.GetDocumentIdsWithFilePath(path))

DocumentHighlighting\AbstractDocumentHighlightsService.cs (4)

39var solution = document.Project.Solution; 73var solution = document.Project.Solution; 126symbol, document.Project.Solution, progress, 166var solution = startingDocument.Project.Solution;

DocumentSpanExtensions.cs (1)

16var solution = documentSpan.Document.Project.Solution;

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

3372? new(await oldProject.Solution.GetRequiredDocument(oldDeclaration.SyntaxTree).GetRequiredNullableDisabledSemanticModelAsync(cancellationToken).ConfigureAwait(false))

EditAndContinue\DebuggingSession.cs (3)

495var analysis = await EditSession.Analyses.GetDocumentAnalysisAsync(LastCommittedSolution, document.Project.Solution, oldDocument, document, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false); 858var newSolution = newProject.Solution; 899var analysis = await EditSession.Analyses.GetDocumentAnalysisAsync(LastCommittedSolution, newUnmappedDocument.Project.Solution, oldUnmappedDocument, newUnmappedDocument, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false);

EditAndContinue\EditSession.cs (2)

549var generatorDiagnostics = await project.Solution.CompilationState.GetSourceGeneratorDiagnosticsAsync(project.State, cancellationToken).ConfigureAwait(false); 561return await project.Solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, cancellationToken).ConfigureAwait(false);

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (1)

145document.Project.Solution,

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (1)

170document.Project.Solution,

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

48project.Solution.Services, project, semanticModel, textSpans, options, result, cancellationToken);

EncapsulateField\AbstractEncapsulateFieldService.cs (5)

118var solution = document.Project.Solution; 146var currentSolution = document.Project.Solution; 182var solution = document.Project.Solution; 222document, document.Project.Solution, field, generatedProperty, cancellationToken).ConfigureAwait(false); 227return documentWithProperty.Project.Solution;

Extensions\ExtensionMessageHandlerService_RemoteOrLocal.cs (1)

122document.Project.Solution,

ExternalAccess\UnitTesting\API\UnitTestingSearchHelpers.cs (4)

31var client = await RemoteHostClient.TryGetClientAsync(project.Solution.Services, cancellationToken).ConfigureAwait(false); 42return await location.Value.Value.TryRehydrateAsync(project.Solution, cancellationToken).ConfigureAwait(false); 54var client = await RemoteHostClient.TryGetClientAsync(project.Solution.Services, cancellationToken).ConfigureAwait(false); 67result.AddIfNotNull(await location.TryRehydrateAsync(project.Solution, cancellationToken).ConfigureAwait(false));

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (2)

176var solution = thisDocument.Project.Solution; 223var solution = project.Solution;

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

29var solution = context.Document.Project.Solution;

ExtractClass\ExtractClassWithDialogCodeAction.cs (4)

57var extractClassService = _service ?? _document.Project.Solution.Services.GetRequiredService<IExtractClassOptionsService>(); 74_document.Project.Solution, 116updatedDocument.Project.Solution, 255unformattedSolution = document.WithSyntaxRoot(currentRoot).Project.Solution;

ExtractInterface\AbstractExtractInterfaceService.cs (6)

138var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 195unformattedInterfaceDocument.Project.Solution, 234var unformattedSolution = documentWithInterface.Project.Solution; 267var service = document.Project.Solution.Services.GetRequiredService<IExtractInterfaceOptionsService>(); 301formattedSolution = simplifiedDocument.Project.Solution; 345unformattedSolution = document.WithSyntaxRoot(editor.GetChangedRoot()).Project.Solution;

ExtractMethod\MethodExtractor.cs (2)

127if (!codeGenService.CanAddTo(destination, document.Project.Solution, cancellationToken)) 154var services = document.Project.Solution.Services;

FindUsages\AbstractFindUsagesService_FindImplementations.cs (2)

44var solution = project.Solution; 76var solution = project.Solution;

FindUsages\AbstractFindUsagesService_FindReferences.cs (5)

31document.Project.Solution, definitionTrackingContext.GetDefinitions(), cancellationToken).ConfigureAwait(false); 132var solution = project.Solution; 165project.Solution, symbol, context, searchOptions, classificationOptions); 167symbol, project.Solution, progress, documents: null, searchOptions, cancellationToken); 222var solution = document.Project.Solution;

FindUsages\FindUsagesHelpers.cs (1)

59var mappingService = document.Project.Solution.Services.GetService<ISymbolMappingService>();

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

150document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (2)

41var languageServices = project.Solution.Services.GetLanguageServices(_state.ContainingType.Language); 85_document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (3)

113priorDocument.Project.Solution, codeAction, progressTracker, cancellationToken).ConfigureAwait(false); 163if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 247var globalOptions = document.Project.Solution.Services.GetService<ILegacyGlobalOptionsWorkspaceService>();

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

74_document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (3)

44var service = _service._pickMembersService_forTesting ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 62var globalOptions = _document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 81var solution = _document.Project.Solution;

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (2)

56if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 111var globalOptions = document.Project.Solution.Services.GetService<ILegacyGlobalOptionsWorkspaceService>();

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndHashWithDialogCodeAction.cs (2)

45var service = _service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 57var solution = _document.Project.Solution;

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (3)

40var services = _document.Project.Solution.Services; 74_document.Project.Solution, 84new ApplyChangesOperation(newDocument.Project.Solution),

GenerateType\AbstractGenerateTypeService.CodeAction.cs (3)

101var generateTypeOptionsService = _document.Project.Solution.Services.GetRequiredService<IGenerateTypeOptionsService>(); 102var notificationService = _document.Project.Solution.Services.GetService<INotificationService>(); 103var projectManagementService = _document.Project.Solution.Services.GetService<IProjectManagementService>();

GenerateType\AbstractGenerateTypeService.cs (2)

109if (document.Project.Solution.CanApplyChange(ApplyChangesKind.AddDocument)) 152semanticDocument.Document.GetLanguageService<ICodeGenerationService>().CanAddTo(decl, semanticDocument.Project.Solution, cancellationToken);

GenerateType\AbstractGenerateTypeService.Editor.cs (9)

69Contract.ThrowIfFalse(document.Project.Solution == generateTypeOptionsResult.Project.Solution); 272var newSolution = projectToBeUpdated.Solution.AddDocument(newDocumentId, documentName, string.Empty, folders, fullFilePath); 349var updatedSolution = projectToBeUpdated.Solution.AddDocument( 390var solution = _semanticDocument.Project.Solution; 399return [new ApplyChangesOperation(codeGenResult.Project.Solution)]; 436var solution = _semanticDocument.Project.Solution; 549var solution = _semanticDocument.Project.Solution; 559return [new ApplyChangesOperation(codeGenResult.Project.Solution)];

GenerateType\AbstractGenerateTypeService.State.cs (3)

295var symbol = await SymbolFinder.FindSourceDefinitionAsync(TypeToGenerateInOpt, document.Project.Solution, cancellationToken).ConfigureAwait(false); 305var documentToBeGeneratedIn = document.Project.Solution.GetDocument(sourceTreeToBeGeneratedIn); 327if (!CodeGenerator.CanAdd(document.Project.Solution, TypeToGenerateInOpt, cancellationToken))

GoToBase\AbstractGoToBaseService.cs (1)

43var solution = project.Solution;

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (1)

26var services = document.Project.Solution.Services;

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

37var solution = document.Project.Solution;

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (3)

58var solution = project.Solution; 88var mappingService = document.Project.Solution.Services.GetRequiredService<ISymbolMappingService>(); 247var destinationDocument = document.Project.Solution.GetDocument(groupSyntaxTree);

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (2)

608var editor = new SyntaxEditor(root, document.Project.Solution.Services); 645var editor = new SyntaxEditor(root, document.Project.Solution.Services);

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (3)

377var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 435var solutionWithAssignmentAdded = documentWithMemberAdded.Project.Solution; 480var services = document.Project.Solution.Services;

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

336var solution = document.Project.Solution;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

54var calleeDocument = document.Project.Solution.GetRequiredDocument(calleeMethodNode.SyntaxTree); 296.FindReferencesAsync(symbol, document.Project.Solution, ImmutableHashSet<Document>.Empty.Add(document), cancellationToken)

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

164var calleeDocument = document.Project.Solution.GetRequiredDocument(calleeMethodNode.SyntaxTree); 441.FindReferencesAsync(parameterSymbol, document.Project.Solution, ImmutableHashSet<Document>.Empty.Add(document), cancellationToken).ConfigureAwait(false);

InlineTemporary\AbstractInlineTemporaryCodeRefactoringProvider.cs (1)

40local, document.Project.Solution, options, cancellationToken).ConfigureAwait(false);

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (3)

51if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 245var modifiedSolution = originalDocument.Project.Solution; 280methodSymbol, document.Project.Solution, progress,

IntroduceVariable\IntroduceVariableCodeRefactoringProvider.cs (1)

26if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

49var editor = new SyntaxEditor(root, document.Project.Solution.Services);

MetadataAsSource\AbstractMetadataAsSourceService.cs (1)

33document.Project.Solution,

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (2)

202var newLoader = new WorkspaceFileTextLoader(temporaryDocument.Project.Solution.Services, fileInfo.TemporaryFilePath, MetadataAsSourceGeneratedFileInfo.Encoding); 322: sourceProject.Solution.Services.GetLanguageServices(fileInfo.LanguageName).GetRequiredService<ISyntaxTreeFactoryService>().GetDefaultParseOptionsWithLatestLanguageVersion();

MetadataAsSource\SymbolMappingServiceFactory.cs (1)

34if (document.Project.Solution.WorkspaceKind is not WorkspaceKind.MetadataAsSource)

MoveStaticMembers\AbstractMoveStaticMembersRefactoringProvider.cs (1)

24var service = document.Project.Solution.Services.GetService<IMoveStaticMembersOptionsService>();

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (5)

66var destinationDocId = _document.Project.Solution.GetDocumentIdsWithFilePath(moveOptions.FilePath).Single(); 71_document.Project.Solution, 103sourceDoc.Project.Solution, 118var memberReferenceLocations = await FindMemberReferencesAsync(newDoc.Project.Solution, newDoc.Project.Id, moveOptions.SelectedMembers, cancellationToken).ConfigureAwait(false); 120var solutionWithFixedReferences = await RefactorReferencesAsync(projectToLocations, newDoc.Project.Solution, newType, typeArgIndices, cancellationToken).ConfigureAwait(false);

MoveToNamespace\AbstractMoveToNamespaceService.cs (2)

226var originalSolution = document.Project.Solution; 280var solution = formattedDocument.Project.Solution;

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

43if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

59var linkedDocument = document.Project.Solution.GetRequiredDocument(linkedDocumentId);

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (2)

33var solution = document.Project.Solution; 107var solution = document.Project.Solution;

NavigateTo\RoslynNavigateToItem.cs (1)

148var solution = firstProject.Solution;

Navigation\AbstractNavigableItemsService.cs (1)

49var solution = project.Solution;

Navigation\INavigableItem.cs (1)

61document.Project.Solution.TryGetWorkspace());

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (2)

30_service ??= document.Project.Solution.Services.GetService<IPullMemberUpOptionsService>(); 56document.Project.Solution,

PullMemberUp\MembersPuller.cs (2)

96var solution = document.Project.Solution; 271var solution = document.Project.Solution;

QuickInfo\CommonSemanticQuickInfoProvider.cs (3)

34var services = context.Document.Project.Solution.Services; 64var services = document.Project.Solution.Services; 86var solution = document.Project.Solution;

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

70var solution = document.Project.Solution;

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

89var referencedSymbols = await SymbolFinder.FindReferencesAsync(symbol, document.Project.Solution, documentsToBeSearched, cancellationToken).ConfigureAwait(false);

Rename\SymbolicRenameInfo.cs (2)

176semanticModel, triggerToken.SpanStart, document.Project.Solution.Services, cancellationToken: cancellationToken).ConfigureAwait(false); 222var solution = document.Project.Solution;

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

162var originalSolution = project.Solution; 216return originalDocument.Project.Solution; 220var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Services);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (2)

84var originalSolution = document.Project.Solution; 220var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Services);

SemanticSearch\SemanticSearchDocumentSupportsFeatureService.cs (1)

21return solutionService.Value.GetQueryDocumentId(document.Project.Solution) == document.Id;

Shared\Extensions\DocumentExtensions.cs (2)

64values = await getItemsWorker(document.Project.Solution.GetRequiredDocument(linkedDocumentId)).ConfigureAwait(false); 81var solution = document.Project.Solution;

Shared\Utilities\AnnotatedSymbolMapping.cs (1)

101annotatedSolution = document.WithSyntaxRoot(root.Value).Project.Solution;

Shared\Utilities\ExtractTypeHelpers.cs (2)

85newDocument.Project.Solution, 128return Formatter.Format(syntaxGenerator.SyntaxGeneratorInternal.TypeParameterList(typeParameterNames), document.Project.Solution.Services, formattingOptions, cancellationToken).ToString();

SignatureHelp\AbstractSignatureHelpProvider.cs (1)

293var platformData = new SupportedPlatformData(document.Project.Solution, invalidProjectsForCurrentSymbol.ToImmutableAndClear(), totalProjects);

SignatureHelp\SignatureHelpService.cs (1)

67var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

128var passThroughOptions = document.Project.Solution.Options;

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (2)

89var solution = invocationDocument.Project.Solution; 218method, invocationDocument.Project.Solution, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\ConvertToAsync\AbstractConvertToAsyncCodeFixProvider.cs (1)

60var otherDocument = document.Project.Solution.GetRequiredDocument(syntaxTree);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (5)

106if (!CodeGenerator.CanAdd(_document.Project.Solution, TypeToGenerateIn, cancellationToken)) 237=> _document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(language).GetRequiredService<TLanguageService>(); 397var definition = await SymbolFinderInternal.FindSourceDefinitionAsync(original, _document.Project.Solution, cancellationToken).ConfigureAwait(false); 445document.Project.Solution, 491document.Project.Solution,

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.State.cs (1)

79var destinationProvider = semanticDocument.Project.Solution.Services.GetLanguageServices(ClassType.Language);

src\Analyzers\Core\CodeFixes\GenerateDefaultConstructors\GenerateDefaultConstructorsCodeAction.cs (1)

35_document.Project.Solution,

src\Analyzers\Core\CodeFixes\GenerateEnumMember\AbstractGenerateEnumMemberService.CodeAction.cs (2)

24var languageServices = _document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(_state.TypeToGenerateIn.Language); 34_document.Project.Solution,

src\Analyzers\Core\CodeFixes\GenerateEnumMember\AbstractGenerateEnumMemberService.State.cs (2)

67var sourceType = (await SymbolFinderInternal.FindSourceDefinitionAsync(TypeToGenerateIn, document.Project.Solution, cancellationToken).ConfigureAwait(false)) as INamedTypeSymbol; 72return CodeGenerator.CanAdd(document.Project.Solution, TypeToGenerateIn, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.CodeAction.cs (3)

64var syntaxFactory = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language).GetService<SyntaxGenerator>(); 72_document.Project.Solution, 88_document.Project.Solution,

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.cs (1)

51var semanticFacts = document.Project.Solution.Workspace.Services

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (1)

121var languageServiceProvider = Document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(State.TypeToGenerateIn.Language);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.State.cs (3)

61TypeToGenerateIn = await SymbolFinderInternal.FindSourceDefinitionAsync(TypeToGenerateIn, document.Project.Solution, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol; 72if (!CodeGenerator.CanAdd(document.Project.Solution, TypeToGenerateIn, cancellationToken)) 85var destinationProvider = document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(TypeToGenerateIn.Language);

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\TypeParameterSubstitution.cs (2)

88var solution = _project.Solution; 126var solution = _project.Solution;

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.CodeAction.cs (2)

53_semanticDocument.Project.Solution, 108var syntaxFactory = _semanticDocument.Project.Solution.Services

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (1)

47var canGenerateMember = CodeGenerator.CanAdd(document.Project.Solution, state.TypeToGenerateIn, cancellationToken);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (2)

153TypeToGenerateIn, _document.Project.Solution, cancellationToken).ConfigureAwait(false) as INamedTypeSymbol; 162return CanGenerateLocal() || CodeGenerator.CanAdd(_document.Project.Solution, TypeToGenerateIn, cancellationToken);

src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (1)

54if (!CodeGenerator.CanAdd(document.Project.Solution, classType, cancellationToken))

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.State.cs (1)

55if (!CodeGenerator.CanAdd(document.Project.Solution, classOrStructType, cancellationToken))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (1)

90this.Document.Project.Solution,

src\Analyzers\Core\CodeFixes\MakeMethodAsynchronous\AbstractMakeMethodAsynchronousCodeFixProvider.cs (2)

168var solution = document.Project.Solution; 198var solution = document.Project.Solution;

src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (5)

77var solution = document.Project.Solution; 110var newSolution = newDocument.Project.Solution; 138[methodSymbol], document.Project.Solution, cancellationToken).ConfigureAwait(false); 146document.Project.Solution, [.. referencedSymbol.Locations], cancellationToken).ConfigureAwait(false); 151return document.Project.Solution;

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.cs (3)

27var service = context.Document.Project.Solution.Services.GetRequiredService<ISupportedChangesService>(); 63var newSolution = await renameActionSet.UpdateSolutionAsync(documentWithInvalidFolders.Project.Solution, cancellationToken).ConfigureAwait(false); 64Debug.Assert(newSolution != document.Project.Solution);

src\Analyzers\Core\CodeFixes\MatchFolderAndNamespace\AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

45fixAllContext.Project.Solution,

src\Analyzers\Core\CodeFixes\NamingStyle\NamingStyleCodeFixProvider.cs (2)

92document.Project.Solution, 107document.Project.Solution, symbol, new SymbolRenameOptions(), fixedName,

src\Analyzers\Core\CodeFixes\RemoveAsyncModifier\AbstractRemoveAsyncModifierCodeFixProvider.cs (1)

67var solutionServices = document.Project.Solution.Services;

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (2)

303var editor = new SyntaxEditor(root, document.Project.Solution.Services); 923var referencedSymbols = await SymbolFinder.FindReferencesAsync(local, document.Project.Solution, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\UnsealClass\AbstractUnsealClassCodeFixProvider.cs (3)

43type, document.Project.Solution, cancellationToken).ConfigureAwait(false); 50c => UnsealDeclarationsAsync(document.Project.Solution, definition.DeclaringSyntaxReferences, c), 66var editor = new SyntaxEditor(root, document.Project.Solution.Services);

src\Analyzers\Core\CodeFixes\UpgradeProject\AbstractUpgradeProjectCodeFixProvider.cs (1)

44var solution = project.Solution;

src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

85var solution = context.Document.Project.Solution; 248var editor = new SyntaxEditor(declaratorTreeRoot, fieldDocument.Project.Solution.Services);

src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (1)

56var nestedEditor = new SyntaxEditor(root, document.Project.Solution.Services);

SymbolMapping\SymbolMappingResult.cs (1)

21public Solution Solution => Project.Solution;

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

40var solution = projects[0].Solution;

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

200if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

ValueTracking\ValueTracker.cs (3)

26var operationCollector = new OperationCollector(progressCollector, document.Project.Solution); 36var solution = document.Project.Solution; 68await progressCollector.TryReportAsync(document.Project.Solution, node.GetLocation(), symbol, cancellationToken).ConfigureAwait(false);

ValueTracking\ValueTrackingService.cs (1)

36var solution = document.Project.Solution;