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)

58var services = document.Project.Solution.Services; 66var 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)

57this.OriginalDocument.Project.Solution, cancellationToken).ConfigureAwait(false)); 73return 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)

132var project = _document.Project;

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (2)

49context.Document.Project, identity, context.CancellationToken).ConfigureAwait(false); 59var 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)

32var 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)

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

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

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

CodeFixes\Service\CodeFixService.cs (16)

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

50document.Project, document.Id, _diagnosticIds, shouldIncludeAnalyzer: null, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false)); 52return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); 63return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false);

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

37new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

165document, 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)

85=> 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)

46var solution = document.Project.Solution; 61var usableFixes = unambiguousFixes.WhereAsArray(fixData => DoesNotAddReference(fixData, document.Project.Id)); 82var solution = document.Project.Solution; 120var newProject = document.Project; 170var services = document.Project.Solution.Services; 220document.Project.Solution, progressTracker, cancellationToken).ConfigureAwait(false); 224newSolution = document.Project.Solution; 240var projectChanges = newDocument.Project.GetChanges(document.Project);

CodeRefactorings\CodeRefactoringService.cs (3)

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

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

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

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

65var solutionWithNewDocument = documentWithMovedType.Project.Solution; 119var projectToBeUpdated = document.Project; 249return updatedDocument.Project.Solution;

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (5)

134var solution = document.Project.Solution; 193var solution = document.Project.Solution; 346var solution = document.Project.Solution; 552symbol, document.Project.Solution, progress, documents: null, 839var 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)

77var 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)

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

141document.Project.Solution, 188var syntaxFacts = memberContainingDocument.Project.Services.GetRequiredService<ISyntaxFactsService>();

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

22var solution = originatingDocument.Project.Solution;

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (2)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

263supportedPlatformData = new SupportedPlatformData(completionContext.Document.Project.Solution, invalidProjects.ToImmutable(), totalProjects); 412var 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)

63var project = document.Project; 128var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

57_cacheService = GetCacheService(document.Project); 89source: GetAllRelevantPeReferences(_originatingDocument.Project), 96source: GetAllRelevantProjects(_originatingDocument.Project), 134GetCacheService(_originatingDocument.Project).WorkQueue.AddWork(_originatingDocument.Project); 176var compilation = project == _originatingDocument.Project 185if (project == _originatingDocument.Project) 205_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); 393var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 397return 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;

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (1)

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

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (7)

192var hostServices = document.Project.Solution.Services 193.GetLanguageServices(document.Project.Language).HostLanguageServices; 222var solution = document.Project.Solution; 427document.Project, tupleType, cancellationToken).ConfigureAwait(false), 429document.Project, tupleType, cancellationToken).ConfigureAwait(false), 523var solution = startingDocument.Project.Solution; 585var 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)) 481var compilationOutputs = _debuggingSession.GetCompilationOutputs(document.Project); 482using var debugInfoReaderProvider = GetMethodDebugInfoReader(_debuggingSession.SessionLog, compilationOutputs, document.Project.Name);

EditAndContinue\DebuggingSession.cs (3)

436var project = document.Project; 818if (_isDisposed || !EditSession.InBreakState || !mappedDocument.State.SupportsEditAndContinue() || !mappedDocument.Project.SupportsEditAndContinue()) 825var newProject = mappedDocument.Project;

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (3)

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

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (2)

178if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 190document.Project.Solution,

EditAndContinue\TraceLog.cs (3)

64Debug.Assert(document.Project.FilePath != null); 66var projectDir = PathUtilities.GetDirectoryName(document.Project.FilePath)!; 74var directory = CreateSessionDirectory(updateId.SessionId, Path.Combine(document.Project.Name, relativeDir));

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

Extensions\ExtensionMessageHandlerService_RemoteOrLocal.cs (1)

122document.Project.Solution,

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

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

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

466await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, UnitTestingInvocationReasons.DocumentChanged).ConfigureAwait(false); 473await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 578pool.Object.Add(document.Project.Language);

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

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

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (1)

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

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

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

ExtractInterface\AbstractExtractInterfaceService.cs (4)

138var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 152var containingNamespaceDisplay = GetContainingNamespaceDisplay(refactoringResult.TypeToExtractFrom, refactoringResult.DocumentToExtractFrom.Project.CompilationOptions!); 188refactoringResult.DocumentToExtractFrom.Project.Id, 267var service = document.Project.Solution.Services.GetRequiredService<IExtractInterfaceOptionsService>();

ExtractMethod\MethodExtractor.cs (2)

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

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

36var 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)

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

FullyQualify\AbstractFullyQualifyService.cs (3)

42var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 46document.Project, 62var project = document.Project;

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

151document.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)

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

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

311if (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)

395var editor = new SyntaxEditor(root, document.Project.Solution.Services); 597var 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)

339var 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)

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

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (5)

240var modifiedSolution = originalDocument.Project.Solution; 245source: methodCallSites.GroupBy(kvp => kvp.Key.Project), 275methodSymbol, document.Project.Solution, progress, 294if (refLocation.Document.Project.Language == document.Project.Language)

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

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

MetadataAsSource\AbstractMetadataAsSourceService.cs (1)

33document.Project.Solution,

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

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

MetadataAsSource\SymbolMappingServiceFactory.cs (1)

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

MoveToNamespace\AbstractMoveToNamespaceService.cs (2)

226var originalSolution = document.Project.Solution; 307var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (7)

33var solution = document.Project.Solution; 36var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 42document.Project, 107var solution = document.Project.Solution; 161Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project))); 202using var _ = GetPooledHashSet(priorityDocuments.Select(d => d.Project), out var highPriProjects); 217using 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 (5)

95var solution = document.Project.Solution; 97var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 270var solution = document.Project.Solution; 272var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 303var info = codeGenerationService.GetInfo(context, options.GenerationOptions, destinationEditor.OriginalDocument.Project.ParseOptions);

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)

84=> 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\ExtractTypeHelpers.cs (1)

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

SignatureHelp\AbstractSignatureHelpProvider.cs (2)

288invalidProjectsForCurrentSymbol.Add(relatedDocument.Project.Id); 292var platformData = new SupportedPlatformData(document.Project.Solution, invalidProjectsForCurrentSymbol.ToImmutableAndClear(), totalProjects);

SignatureHelp\SignatureHelpService.cs (2)

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

Snippets\AbstractSnippetService.cs (1)

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

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

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

SolutionCrawler\AbstractDocumentDifferenceService.cs (1)

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

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

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

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

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

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

89var solution = invocationDocument.Project.Solution; 218method, 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)

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

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

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

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

451document.Project.Solution, 497document.Project.Solution,

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

41_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\GenerateMember\AbstractGenerateMemberCodeFixProvider.cs (1)

33if (context.Document.Project.IsSubmission)

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\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)

115var supportsImplementingLessAccessibleMember = syntaxFacts.SupportsImplicitImplementationOfNonPublicInterfaceMembers(document.Project.ParseOptions!); 121generateInvisibly: 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)

163var solution = document.Project.Solution; 197return 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)

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

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (1)

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

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