Project

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (3)

50var services = _document.Project.Solution.Services; 66var constructorDocument = _document.Project.GetDocument(syntaxTree); 69return Task.FromResult<Solution?>(constructorDocument.WithSyntaxRoot(newRoot).Project.Solution);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (1)

186priorDocument.Project.Solution, CodeAnalysisProgress.None, postProcessChanges: true, cancellationToken).ConfigureAwait(false);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)

104var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

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

AddImport\AbstractAddImportCodeFixProvider.cs (2)

59var services = document.Project.Solution.Services; 67var packageSources = installerService?.IsEnabled(document.Project.Id) == true

AddImport\AbstractAddImportFeatureService.cs (5)

69var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 73document.Project.Solution, 144var project = document.Project; 542var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 546document.Project.Solution,

AddImport\AddImportOptions.cs (1)

34return configOptions.GetAddImportOptions(document.Project.Services, searchOptions, document.AllowImportsInHiddenRegions());

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (1)

41var newProject = newDocument.Project;

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (2)

59this.OriginalDocument.Project.Solution, cancellationToken).ConfigureAwait(false)); 75return updatedDocument.Project.Solution;

AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs (2)

38=> fixData.ProjectReferenceToAdd != null && fixData.ProjectReferenceToAdd != originalDocument.Project.Id; 52return Task.FromResult<CodeActionOperation?>(new AddProjectReferenceCodeActionOperation(OriginalDocument.Project.Id, FixData.ProjectReferenceToAdd, applyOperation));

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

57var updatedProject = await UpdateProjectAsync(updatedDocument.Project, isPreview, cancellationToken).ConfigureAwait(false); 58return updatedProject ?? new ApplyChangesOperation(updatedDocument.Project.Solution);

AddImport\References\ProjectSymbolReference.cs (4)

36return document.Project.Id == _project.Id 51=> document.Project.Id != _project.Id; 60if (document.Project.Id == _project.Id) 92var project = document.Project;

AddImport\SymbolReferenceFinder.cs (1)

96=> DoAsync(new AllSymbolsProjectSearchScope(_owner, _document.Project, exact), cancellationToken);

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

134var project = _document.Project;

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (2)

51context.Document.Project, identity, context.CancellationToken).ConfigureAwait(false); 61var compilation = await context.Document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

AddPackage\AbstractAddPackageCodeFixProvider.cs (2)

34var workspaceServices = document.Project.Solution.Services; 38!installerService.IsEnabled(document.Project.Id))

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

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

BraceMatching\AbstractEmbeddedLanguageBraceMatcher.cs (1)

46var result = braceMatcher.Value.FindBraces(document.Project, semanticModel, token, position, options, cancellationToken);

BraceMatching\BraceMatchingService.cs (1)

34var matchers = _braceMatchers.Where(b => b.Metadata.Language == document.Project.Language);

ChangeSignature\AbstractChangeSignatureService.cs (2)

110symbol = SymbolFinder.FindSourceDefinition(symbol, document.Project.Solution, cancellationToken) ?? symbol; 161var solution = document.Project.Solution;

CodeFixes\Configuration\ConfigurationUpdater.cs (2)

270var solution = editorConfigDocument.Project.Solution; 314currentSolution = addedAnalyzerConfigDocument.Project.Solution;

CodeFixes\Configuration\ConfigureCodeStyle\ConfigureCodeStyleOptionCodeFixProvider.cs (1)

57=> Task.FromResult(GetConfigurations(document.Project, diagnostics));

CodeFixes\Configuration\ConfigureSeverity\ConfigureSeverityLevelCodeFixProvider.cs (1)

48=> Task.FromResult(GetConfigurations(document.Project, diagnostics, cancellationToken));

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

37new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

168document, document.Project, diagnostics, suppressionTargetInfo, skipSuppressMessage, skipUnsuppress, cancellationToken).ConfigureAwait(false);

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

73var currentSolution = triggerDocument.Project.Solution; 74foreach (var grouping in diagnosticsByDocument.GroupBy(d => d.Key.Project))

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

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

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

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

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

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

CodeFixes\Suppression\WrapperCodeFixProvider.cs (1)

35var suppressionFixes = await SuppressionFixProvider.GetFixesAsync(context.Document.Project, projectDiagnostics, context.CancellationToken).ConfigureAwait(false);

CodeLens\CodeLensReferencesService.cs (1)

256return !string.IsNullOrEmpty(fullName) ? new ReferenceMethodDescriptor(fullName, document.FilePath, document.Project.OutputFilePath) : null;

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (8)

62var solution = document.Project.Solution; 77var usableFixes = unambiguousFixes.WhereAsArray(fixData => DoesNotAddReference(fixData, document.Project.Id)); 100var solution = document.Project.Solution; 127var newProject = document.Project; 174var services = document.Project.Solution.Services; 224document.Project.Solution, progressTracker, cancellationToken).ConfigureAwait(false); 228newSolution = document.Project.Solution; 244var projectChanges = newDocument.Project.GetChanges(document.Project);

CodeRefactorings\CodeRefactoringService.cs (3)

66if (LanguageToProvidersMap.TryGetValue(document.Project.Language, out var lazyProviders)) 76if (document.Project.Solution.WorkspaceKind == WorkspaceKind.Interactive) 213var extensionManager = textDocument.Project.Solution.Services.GetRequiredService<IExtensionManager>();

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

58return document.Project.Solution; 71return modifiedSolution ?? document.Project.Solution;

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

64var solutionWithNewDocument = documentWithMovedType.Project.Solution; 118var projectToBeUpdated = document.Project; 248return updatedDocument.Project.Solution;

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

86return changedDocument.Project.Solution;

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (5)

134var solution = document.Project.Solution; 194var solution = document.Project.Solution; 347var solution = document.Project.Solution; 553symbol, document.Project.Solution, progress, documents: null, 840var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

40var solution = _state.Document.Project.Solution; 41var newDocumentId = DocumentId.CreateNewId(document.Project.Id, document.Name); 67var projectRootFolder = FolderInfo.CreateFolderHierarchyForProject(document.Project);

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

157var projectRoot = PathUtilities.GetDirectoryName(document.Project.FilePath); 171var solution = document.Project.Solution;

Common\AbstractProjectExtensionProvider.cs (1)

82var extensions = GetExtensions(document.Project);

Completion\CommonCompletionProvider.cs (1)

79var snippetService = document.Project.Services.GetService<ISnippetInfoService>();

Completion\CompletionOptions.cs (1)

79var solution = document.Project.Solution;

Completion\CompletionProvider.cs (2)

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

Completion\CompletionService.cs (4)

211var provider = GetProvider(item, document.Project); 215var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 244var provider = GetProvider(item, document.Project); 247var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\CompletionService_GetCompletions.cs (7)

48var passThroughOptions = options ?? document.Project.Solution.Options; 78var providers = _providerManager.GetFilteredProviders(document.Project, roles, trigger, options); 137if (ShouldTriggerCompletion(document.Project, document.Project.Services, text, caretPosition, trigger, options, passThroughOptions, roles)) 139var triggeredProviders = providers.Where(p => p.ShouldTriggerCompletion(document.Project.Services, text, caretPosition, trigger, options, passThroughOptions)).ToImmutableArrayOrEmpty(); 155var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 329var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\Providers\AbstractAggregateEmbeddedLanguageCompletionProvider.cs (1)

92foreach (var language in GetLanguageProviders(context.Document.Project.Services))

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (4)

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

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)

159document.Project.Solution,

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

22var solution = originatingDocument.Project.Solution;

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (2)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

214supportedPlatformData = new SupportedPlatformData(completionContext.Document.Project.Solution, invalidProjects, totalProjects); 360var solution = document.Project.Solution;

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

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

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

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

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

30typeImportCompletionService.QueueCacheWarmUpTask(document.Project);

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.cs (2)

60var project = document.Project; 125var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

57_cacheService = GetCacheService(document.Project); 92source: GetAllRelevantPeReferences(_originatingDocument.Project), 99source: GetAllRelevantProjects(_originatingDocument.Project), 137GetCacheService(_originatingDocument.Project).WorkQueue.AddWork(_originatingDocument.Project); 179var compilation = project == _originatingDocument.Project 188if (project == _originatingDocument.Project) 208_originatingDocument.Project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false);

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

139var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 147document.Project.Solution.Services,

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

39var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

Completion\Providers\Scripting\AbstractDirectivePathCompletionProvider.cs (1)

167if (document.Project.CompilationOptions?.MetadataReferenceResolver is RuntimeMetadataReferenceResolver resolver)

Completion\Providers\Scripting\AbstractReferenceDirectiveCompletionProvider.cs (1)

51var resolver = context.Document.Project.CompilationOptions.MetadataReferenceResolver as RuntimeMetadataReferenceResolver;

Completion\Providers\SymbolCompletionItem.cs (7)

139var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 150var linkedDoc = document.Project.Solution.GetRequiredDocument(id); 201var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 205var services = document.Project.Solution.Services; 216return document.Project.Solution.GetRequiredDocument(contextId); 361var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 365return await CommonCompletionUtilities.CreateDescriptionAsync(document.Project.Solution.Services, semanticModel, position, symbols, options, supportedPlatforms, cancellationToken).ConfigureAwait(false);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

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

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

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

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 194.GetLanguageServices(document.Project.Language).HostLanguageServices; 223var solution = document.Project.Solution; 428document.Project, tupleType, cancellationToken).ConfigureAwait(false), 430document.Project, tupleType, cancellationToken).ConfigureAwait(false), 524var solution = startingDocument.Project.Solution; 586var currentSolution = startingDocument.Project.Solution;

DesignerAttribute\DesignerAttributeDiscoveryService.cs (2)

396if (RemoteSupportedLanguages.IsSupported(activeDocument?.Project.Language)) 401activeDocument.Project,

DocumentHighlighting\AbstractDocumentHighlightsService.cs (8)

39var solution = document.Project.Solution; 41var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 47document.Project, 73var solution = document.Project.Solution; 126symbol, document.Project.Solution, progress, 166var solution = startingDocument.Project.Solution; 184if (currentDocument.Project.Language == startingDocument.Project.Language)

DocumentSpanExtensions.cs (1)

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

EditAndContinue\CommittedSolution.cs (3)

209if (committedDocument == null && !solution.ContainsProject(document.Project.Id)) 474var compilationOutputs = _debuggingSession.GetCompilationOutputs(document.Project); 475using var debugInfoReaderProvider = GetMethodDebugInfoReader(compilationOutputs, document.Project.Name);

EditAndContinue\DebuggingSession.cs (3)

419var project = document.Project; 788if (_isDisposed || !EditSession.InBreakState || !mappedDocument.State.SupportsEditAndContinue() || !mappedDocument.Project.SupportsEditAndContinue()) 795var newProject = mappedDocument.Project;

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (3)

79var oldProject = oldDocument?.Project ?? oldSolution.GetRequiredProject(newDocument.Project.Id); 131var analyzer = newDocument.Project.Services.GetRequiredService<IEditAndContinueAnalyzer>();

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (2)

177if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 189document.Project.Solution,

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

41var project = document.Project;

EncapsulateField\AbstractEncapsulateFieldService.cs (7)

117var solution = document.Project.Solution; 145var currentSolution = document.Project.Solution; 181var solution = document.Project.Solution; 221document, document.Project.Solution, field, generatedProperty, cancellationToken).ConfigureAwait(false); 226return documentWithProperty.Project.Solution; 235var projectId = document.Project.Id; 252var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\AbstractUnitTestingDocumentDifferenceService.cs (1)

21var syntaxFactsService = newDocument.Project.Services.GetService<ISyntaxFactsService>();

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (3)

472await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, UnitTestingInvocationReasons.DocumentChanged).ConfigureAwait(false); 479await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 584pool.Object.Add(document.Project.Language);

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

139EnqueueFullProjectDependency(document.Project, assembly); 176var solution = thisDocument.Project.Solution;

ExternalAccess\VSTypeScript\VSTypeScriptDocumentDiagnosticAnalyzer.cs (2)

20var analyzer = document.Project.Services.GetRequiredService<VSTypeScriptDiagnosticAnalyzerLanguageService>().Implementation; 31var analyzer = document.Project.Services.GetRequiredService<VSTypeScriptDiagnosticAnalyzerLanguageService>().Implementation;

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

65foreach (var group in priorityDocuments.GroupBy(d => d.Project))

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

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

ExtractInterface\AbstractExtractInterfaceService.cs (6)

140var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 154var containingNamespaceDisplay = GetContainingNamespaceDisplay(refactoringResult.TypeToExtractFrom, refactoringResult.DocumentToExtractFrom.Project.CompilationOptions!); 190refactoringResult.DocumentToExtractFrom.Project.Id, 268var notificationService = document.Project.Solution.Services.GetRequiredService<INotificationService>(); 271var service = document.Project.Solution.Services.GetRequiredService<IExtractInterfaceOptionsService>(); 280document.Project.Language,

ExtractMethod\MethodExtractor.CodeGenerator.cs (1)

151document.Project.ParseOptions);

ExtractMethod\MethodExtractor.cs (2)

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

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

38var options = await classificationOptions.GetOptionsAsync(document.Project.Services, cancellationToken).ConfigureAwait(false);

FindUsages\AbstractFindUsagesService_FindReferences.cs (2)

31document.Project.Solution, definitionTrackingContext.GetDefinitions(), cancellationToken).ConfigureAwait(false); 222var solution = document.Project.Solution;

FindUsages\DefinitionItemFactory.cs (1)

302var options = await optionsProvider.GetOptionsAsync(document.Project.Services, cancellationToken).ConfigureAwait(false);

FindUsages\FindUsagesHelpers.cs (1)

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

FullyQualify\AbstractFullyQualifyService.cs (3)

43var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 47document.Project, 63var project = document.Project;

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

152document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

112priorDocument.Project.Solution, codeAction, progressTracker, cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (3)

42var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); 64var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); 121var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (2)

268var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable(document.Project.Language); 282var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(document.Project.Language);

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (2)

40var services = _document.Project.Solution.Services; 74_document.Project.Solution,

GenerateType\AbstractGenerateTypeService.CodeAction.cs (4)

102var generateTypeOptionsService = _document.Project.Solution.Services.GetRequiredService<IGenerateTypeOptionsService>(); 103var notificationService = _document.Project.Solution.Services.GetService<INotificationService>(); 104var projectManagementService = _document.Project.Solution.Services.GetService<IProjectManagementService>(); 107var isPublicOnlyAccessibility = IsPublicOnlyAccessibility(_state, _document.Project);

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

312if (newDocument.Project.Language == _semanticDocument.Document.Project.Language)

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (2)

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

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

36var solution = document.Project.Solution;

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (9)

55project = document.Project; 88var mappingService = document.Project.Solution.Services.GetRequiredService<ISymbolMappingService>(); 122return (document.Project, SymbolAndLineNumberArray.Empty); 137var remapped = remappedProject != document.Project; 215var projectState = document.Project.State; 217var languageGlyph = document.Project.Language switch 221_ => throw ExceptionUtilities.UnexpectedValue(document.Project.Language), 247var destinationDocument = document.Project.Solution.GetDocument(groupSyntaxTree); 565? definition.SourceSpans[0].Document.Project.State

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (2)

362var editor = new SyntaxEditor(root, document.Project.Solution.Services); 517var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (6)

377var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 435var solutionWithAssignmentAdded = documentWithMemberAdded.Project.Solution; 448var compilation = await finalSolution.GetRequiredProject(documentWithMemberAdded.Project.Id).GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 480var services = document.Project.Solution.Services; 526var compilation = await documentWithMemberAdded.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 621var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

337var solution = document.Project.Solution;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

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

InlineTemporary\AbstractInlineTemporaryCodeRefactoringProvider.cs (1)

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

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (5)

241var modifiedSolution = originalDocument.Project.Solution; 246source: methodCallSites.GroupBy(kvp => kvp.Key.Project), 276methodSymbol, document.Project.Solution, progress, 295if (refLocation.Document.Project.Language == document.Project.Language)

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

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

MetadataAsSource\AbstractMetadataAsSourceService.cs (1)

35document.Project.Solution,

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

74await generatedDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false),

MetadataAsSource\SymbolMappingServiceFactory.cs (1)

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

MoveToNamespace\AbstractMoveToNamespaceService.cs (2)

211var originalSolution = document.Project.Solution; 292var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

74Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project)));

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (6)

27var solution = document.Project.Solution; 30var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 36document.Project, 82Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project))); 123using var _ = GetPooledHashSet(priorityDocuments.Select(d => d.Project), out var highPriProjects); 138using var _1 = GetPooledHashSet(priorityDocuments.Where(d => project == d.Project), out var highPriDocs);

NavigateTo\NavigateToSearcher.cs (9)

188var project = _activeDocument.Project; 205var activeProject = _activeDocument.Project; 293processedProjects.Add(_activeDocument.Project); 294result.Add([_activeDocument.Project]); 301if (processedProjects.Add(doc.Project)) 302buffer.Add(doc.Project); 332if (_activeDocument?.Project != null && projectsSet.Contains(_activeDocument.Project)) 337if (projectsSet.Contains(doc.Project))

NavigateTo\RoslynNavigateToItem.cs (2)

143var firstProject = itemDocument.Project; 172return itemDocument.Project.Name;

Navigation\INavigableItem.cs (2)

55NavigableProject.FromProject(document.Project), 61document.Project.Solution.TryGetWorkspace());

NavigationBar\AbstractNavigationBarItemService.cs (2)

23var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 30document.Project,

PullMemberUp\MembersPuller.cs (4)

95var solution = document.Project.Solution; 97var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 270var solution = document.Project.Solution; 272var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>();

RelatedDocuments\AbstractRelatedDocumentsService.cs (3)

42var project = document.Project; 51document.Project, 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 (3)

175semanticModel, triggerToken.SpanStart, document.Project.Solution.Services, cancellationToken: cancellationToken).ConfigureAwait(false); 221var solution = document.Project.Solution; 231if (document.Project.IsSubmission)

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

161var project = document.Project; 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\SemanticSearchUtilities.cs (1)

79=> GetQueryDocumentId(document.Project.Solution) == document.Id;

Shared\Extensions\DocumentExtensions.cs (2)

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

Shared\Utilities\ExtractTypeHelpers.cs (1)

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

SignatureHelp\AbstractSignatureHelpProvider.cs (4)

257var totalProjects = relatedDocuments.Select(d => d.Project.Id).Concat(document.Project.Id); 288invalidProjectsForCurrentSymbol.Add(relatedDocument.Project.Id); 292var platformData = new SupportedPlatformData(document.Project.Solution, invalidProjectsForCurrentSymbol, totalProjects);

SignatureHelp\SignatureHelpService.cs (2)

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

Snippets\AbstractSnippetService.cs (1)

42EnsureSnippetsLoaded(context.Document.Project.Language);

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

81var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

SolutionCrawler\AbstractDocumentDifferenceService.cs (1)

22var syntaxFactsService = newDocument.Project.Services.GetService<ISyntaxFactsService>();

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

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

src\Analyzers\Core\CodeFixes\AddObsoleteAttribute\AbstractAddObsoleteAttributeCodeFixProvider.cs (1)

60var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

90var solution = invocationDocument.Project.Solution; 219method, invocationDocument.Project.Solution, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\AnalyzerOptionsProviders.cs (2)

17var analyzerOptions = document.Project.AnalyzerOptions; 20return new AnalyzerOptionsProvider(configOptions, document.Project.Language);

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

72var otherDocument = document.Project.Solution.GetDocument(syntaxTree);

src\Analyzers\Core\CodeFixes\FileHeaders\AbstractFileHeaderCodeFixProvider.cs (1)

65!document.Project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(tree).TryGetEditorConfigOption(CodeStyleOptions2.FileHeaderTemplate, out fileHeaderTemplate))

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

454document.Project.Solution, 500document.Project.Solution,

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

42_document.Project.Solution,

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

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

src\Analyzers\Core\CodeFixes\GenerateMember\AbstractGenerateMemberCodeFixProvider.cs (1)

34if (context.Document.Project.IsSubmission)

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

67var syntaxFactory = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language).GetService<SyntaxGenerator>(); 75_document.Project.Solution, 91_document.Project.Solution,

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

57var semanticFacts = document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(state.TypeToGenerateIn.Language).GetService<ISemanticFactsService>();

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

47var canGenerateMember = CodeGenerator.CanAdd(document.Project.Solution, state.TypeToGenerateIn, cancellationToken); 208var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

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

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceCodeFixProvider.cs (2)

128var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 130var supportsImplicitImplementationOfNonPublicInterfaceMembers = syntaxFacts.SupportsImplicitImplementationOfNonPublicInterfaceMembers(document.Project.ParseOptions!);

src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (2)

110var supportsImplementingLessAccessibleMember = syntaxFacts.SupportsImplicitImplementationOfNonPublicInterfaceMembers(document.Project.ParseOptions!); 116generateInvisibly: generator.ShouldGenerateInvisibleMember(document.Project.ParseOptions!, interfaceMember, interfaceMember.Name, supportsImplementingLessAccessibleMember),

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

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

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

81var compilation = await this.Document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 96this.Document.Project.Solution,

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (2)

50var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 243var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\ImplementType\ImplementTypeOptions.cs (1)

80return configOptions.GetImplementTypeOptions(document.Project.Language);

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

164var solution = document.Project.Solution; 198return newDocument.Project.Solution;

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

77var solution = document.Project.Solution; 99var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 110var newSolution = newDocument.Project.Solution; 151return document.Project.Solution;

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

27var service = context.Document.Project.Solution.Services.GetRequiredService<ISupportedChangesService>(); 54var targetFolders = PathMetadataUtilities.BuildFoldersFromNamespace(targetNamespace, document.Project.DefaultNamespace); 63var newSolution = await renameActionSet.UpdateSolutionAsync(documentWithInvalidFolders.Project.Solution, cancellationToken).ConfigureAwait(false); 64Debug.Assert(newSolution != document.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 (2)

33var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 67var solutionServices = document.Project.Solution.Services;

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

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

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

43type, document.Project.Solution, cancellationToken); 50c => UnsealDeclarationsAsync(document.Project.Solution, definition.DeclaringSyntaxReferences, c),

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

43var project = context.Document.Project;

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

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

SymbolMapping\SymbolMappingServiceFactory.cs (3)

26var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); 30return new SymbolMappingResult(document.Project, symbol); 37=> Task.FromResult(new SymbolMappingResult(document.Project, symbol));

SymbolSearch\SymbolSearchOptions.cs (1)

57return configOptions.GetSymbolSearchOptions(document.Project.Language);

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

170var projectDiagnostics = await GetProjectDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false);

TaskList\AbstractTaskListService.cs (2)

33var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 37document.Project,

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

66var solution = context.Document.Project.Solution; 362return Formatter.Format(newRoot, SpecializedFormattingAnnotation, document.Project.Solution.Services, options, formattingRules, cancellationToken);

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 (2)

33var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 36var solution = document.Project.Solution;

Workspace\CompileTimeSolutionProvider.cs (2)

188var designTimeProjectDirectoryName = PathUtilities.GetDirectoryName(designTimeDocument.Project.FilePath)!; 192var sourceGeneratedDocuments = await compileTimeSolution.GetRequiredProject(designTimeDocument.Project.Id).GetSourceGeneratedDocumentsAsync(cancellationToken).ConfigureAwait(false);