Project

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (3)

79var constructorDocument = _document.Project.GetDocument(syntaxTree); 82return constructorDocument.WithSyntaxRoot(newRoot).Project.Solution; 98var solution = _document.Project.Solution;

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (2)

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

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)

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

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

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

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)

63document.Project.Documents

AddImport\AbstractAddImportCodeFixProvider.cs (2)

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

AddImport\AbstractAddImportCodeRefactoringProvider.cs (1)

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

AddImport\AbstractAddImportFeatureService.cs (5)

70var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 74document.Project.Solution, 146var project = document.Project; 519var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 523document.Project.Solution,

AddImport\AddImportOptions.cs (1)

46document.Project.Services, searchOptions, document.AllowImportsInHiddenRegions(), cleanupDocument);

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (1)

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

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

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

139var project = _document.Project;

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (2)

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

AddPackage\AbstractAddPackageCodeFixProvider.cs (2)

35var workspaceServices = document.Project.Solution.Services; 39!installerService.IsEnabled(document.Project.Id))

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

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

AddPackage\ParentInstallPackageCodeAction.cs (2)

71installerService ??= document.Project.Solution.Services.GetService<IPackageInstallerService>(); 73return installerService?.IsInstalled(document.Project.Id, fixData.PackageName) == false

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

CallHierarchy\AbstractCallHierarchyService.cs (1)

323var item = await CreateItemAsync(symbol, bestLocation.Project, cancellationToken).ConfigureAwait(false);

ChangeSignature\AbstractChangeSignatureService.cs (4)

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

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

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

45var service = document.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 47document.Project, [document.Id], _diagnosticIds, AnalyzerFilter.All, includeLocalDocumentDiagnostics: true, cancellationToken).ConfigureAwait(false)); 49return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false); 54var service = document.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 59return await diagnostics.ToDiagnosticsAsync(document.Project, cancellationToken).ConfigureAwait(false);

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

39new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

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

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

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

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

73var currentSolution = triggerDocument.Project.Solution; 74foreach (var grouping in diagnosticsByDocument.GroupBy(d => d.Key.Project)) 88currentSolution = newDocument.Project.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_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)

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

CodeLens\CodeLensReferencesService.cs (1)

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

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

85var key = new ProviderKey(document.Project.Language, document.Kind, ""); 95key = new ProviderKey(document.Project.Language, document.Kind, documentExtension); 107if (document.Project.Solution.WorkspaceKind == WorkspaceKind.Interactive) 212m[TelemetryLogging.KeyLanguageName] = document.Project.Language; 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; 119var projectToBeUpdated = document.Project; 246return updatedDocument.Project.Solution;

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

83return changedDocument.Project.Solution;

CodeRefactorings\MoveType\MoveTypeCodeRefactoringProvider.cs (1)

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

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (8)

144var solution = document.Project.Solution; 201var solution = document.Project.Solution; 349var solution = document.Project.Solution; 357!PathUtilities.PathsEqual(arg.solution.GetRequiredDocument(id).Project.FilePath!, arg.document.Project.FilePath!), (solution, document))) 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 (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 (3)

157var projectRoot = PathUtilities.GetDirectoryName(document.Project.FilePath); 171var solution = document.Project.Solution; 180documents.Select(d => d.Project.DefaultNamespace),

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

102var languageServices = document?.Project.Services ?? _services.GetLanguageServices(Language); 107var passThroughOptions = options ?? document?.Project.Solution.Options ?? OptionSet.Empty; 109return ShouldTriggerCompletion(document?.Project, languageServices, text, caretPosition, trigger, completionOptions, passThroughOptions, roles); 205var provider = GetProvider(item, document.Project); 209var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 237var provider = GetProvider(item, document.Project); 240var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\CompletionService_GetCompletions.cs (7)

48var passThroughOptions = options ?? document.Project.Solution.Options; 77var providers = _providerManager.GetFilteredProviders(document.Project, roles, trigger, options); 136if (ShouldTriggerCompletion(document.Project, document.Project.Services, text, caretPosition, trigger, options, passThroughOptions, roles)) 138var triggeredProviders = providers.Where(p => p.ShouldTriggerCompletion(document.Project.Services, text, caretPosition, trigger, options, passThroughOptions)).ToImmutableArrayOrEmpty(); 154var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 340var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\Providers\AbstractAggregateEmbeddedLanguageCompletionProvider.cs (1)

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

Completion\Providers\AbstractAwaitCompletionProvider.cs (1)

201document.Project.Solution, semanticModel, declaration, cancellationToken).ConfigureAwait(false);

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)

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

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

34_ = ExtensionMemberImportCompletionHelper.WarmUpCacheAsync(document.Project, CancellationToken.None);

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

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

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

30typeImportCompletionService.QueueCacheWarmUpTask(document.Project);

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

54var currentProject = syntaxContext.Document.Project;

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

66var project = document.Project; 113var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

Completion\Providers\ImportCompletionProvider\ExtensionMemberImportCompletionHelper.SymbolComputer.cs (7)

98source: GetAllRelevantPeReferences(_originatingDocument.Project), 105source: GetAllRelevantProjects(_originatingDocument.Project), 133GetCacheService(_originatingDocument.Project).WorkQueue.AddWork(_originatingDocument.Project); 196var compilation = project == _originatingDocument.Project 205if (project == _originatingDocument.Project) 225_originatingDocument.Project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false);

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

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

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

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

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

52if (context.Document.Project.CompilationOptions.MetadataReferenceResolver is RuntimeMetadataReferenceResolver resolver && pathThroughLastSlash.IndexOfAny(s_pathIndicators) < 0)

Completion\Providers\SymbolCompletionItem.cs (8)

146var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 157var linkedDoc = document.Project.Solution.GetRequiredDocument(id); 158var linkedCompilation = await linkedDoc.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 208var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 212var services = document.Project.Solution.Services; 223return document.Project.Solution.GetRequiredDocument(contextId); 420var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 424return 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);

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

49if (!syntaxFacts.SupportsConstantInterpolatedStrings(document.Project.ParseOptions!))

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

57if (!syntaxFacts.SupportsConstantInterpolatedStrings(document.Project.ParseOptions!))

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (10)

193var hostServices = document.Project.Solution.Services 194.GetLanguageServices(document.Project.Language).HostLanguageServices; 223var solution = document.Project.Solution; 259return document.WithSyntaxRoot(newRoot).Project.Solution; 333foreach (var group in documentsToUpdate.GroupBy(d => d.Document.Project)) 428document.Project, tupleType, cancellationToken).ConfigureAwait(false), 430document.Project, tupleType, cancellationToken).ConfigureAwait(false), 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 (8)

60var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 66document.Project, 116var sourceGeneratedDocuments = await newDocument.Project.GetSourceGeneratedDocumentsAsync(cancellationToken).ConfigureAwait(false); 118var projectDocumentCount = newDocument.Project.DocumentIds.Count; 120var projectConeCount = 1 + document.Project.Solution 122.GetProjectsThatThisProjectTransitivelyDependsOn(document.Project.Id).Count; 214var diagnosticAnalyzerService = newDocument.Project.Solution.Services.GetRequiredService<IDiagnosticAnalyzerService>(); 322args: (@this: this, newDocument.Project.Solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName,

Copilot\IProposalAdjusterService.cs (2)

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

DesignerAttribute\DesignerAttributeDiscoveryService.cs (3)

136var frozenProject = frozenDocument.Project; 396if (RemoteSupportedLanguages.IsSupported(activeDocument?.Project.Language)) 401activeDocument.Project,

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

82var oldDocumentVersion = await GetDiagnosticVersionAsync(oldDocument.Project, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService_GetDiagnosticsForSpan.cs (4)

49var project = document.Project; 289var project = document.Project; 293document.Project, allAnalyzers, hostAnalyzerInfo, this.CrashOnAnalyzerException, cancellationToken).ConfigureAwait(false); 323var version = await GetDiagnosticVersionAsync(document.Project, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService_RemoteOrLocalDispatcher.cs (2)

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

Diagnostics\Service\DocumentAnalysisExecutor.cs (7)

105static (r, d, a, k) => $"Driver: {r != null}, {d.Id}, {d.Project.Id}, {a}, {k}", _compilationWithAnalyzers, textDocument, analyzer, kind); 115var isEnabled = await textDocument.Project.HasSuccessfullyLoadedAsync(cancellationToken).ConfigureAwait(false); 117Logger.Log(FunctionId.Diagnostics_SemanticDiagnostic, static (a, d, e) => $"{a}, ({d.Id}, {d.Project.Id}), Enabled:{e}", analyzer, textDocument, isEnabled); 156var diags = await diagnostics.ToDiagnosticsAsync(textDocument.Project, cancellationToken).ConfigureAwait(false); 173analysisScope, analysisScope.TextDocument.Project, _compilationWithAnalyzers, _logPerformanceInfo, getTelemetryInfo: false, cancellationToken).ConfigureAwait(false); 362var diagnosticSpanMappingService = textDocument.Project.Solution.Services.GetService<IWorkspaceVenusSpanMappingService>(); 370var diagnostic = await diagnosticData.ToDiagnosticAsync(textDocument.Project, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (1)

104await VerifyDiagnosticLocationsAsync(diagnostics, document.Project, cancellationToken).ConfigureAwait(false);

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; 194if (currentDocument.Project.Language == startingDocument.Project.Language)

DocumentSpanExtensions.cs (1)

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

EditAndContinue\CommittedSolution.cs (3)

219if (committedDocument == null && !solution.ContainsProject(document.Project.Id)) 480var compilationOutputs = debuggingSession.GetCompilationOutputs(document.Project); 481using var debugInfoReaderProvider = GetMethodDebugInfoReader(debuggingSession.SessionLog, compilationOutputs, document.Project.Name);

EditAndContinue\DebuggingSession.cs (6)

464var project = document.Project; 495var analysis = await EditSession.Analyses.GetDocumentAnalysisAsync(LastCommittedSolution, document.Project.Solution, oldDocument, document, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false); 716if (!document.Project.SupportsEditAndContinue()) 850if (_isDisposed || !EditSession.InBreakState || !mappedDocument.State.SupportsEditAndContinue() || !mappedDocument.Project.SupportsEditAndContinue()) 857var newProject = mappedDocument.Project; 899var analysis = await EditSession.Analyses.GetDocumentAnalysisAsync(LastCommittedSolution, newUnmappedDocument.Project.Solution, oldUnmappedDocument, newUnmappedDocument, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false);

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (6)

84var oldProject = oldDocument?.Project ?? oldSolution.GetRequiredProject(newDocument!.Project.Id); 85var newProject = newDocument?.Project ?? newSolution.GetRequiredProject(oldProject.Id); 143var analyzer = newDocument.Project.Services.GetRequiredService<IEditAndContinueAnalyzer>(); 177Debug.Assert(oldDocument == null || oldDocument.Project == oldProject); 178Debug.Assert(newDocument == null || newDocument.Project == newProject);

EditAndContinue\EditSession.cs (2)

680reason ??= string.Format(FeaturesResources._0_does_not_support_Hot_Reload, document.Project.Language); 685[document.Name, document.Project.Name, reason]));

EditAndContinue\PdbMatchingSourceTextProvider.cs (1)

95var oldSolutionVersion = oldDocument.Project.Solution.SolutionStateContentVersion;

EditAndContinue\Remote\DebuggingSessionProxy.cs (2)

133if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 145document.Project.Solution,

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (2)

155if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 168document.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)

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; 236var projectId = document.Project.Id; 253var 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 (4)

515await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, UnitTestingInvocationReasons.DocumentChanged).ConfigureAwait(false); 522await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 549list.Add(new UnitTestingWorkItem(document.Id, document.Project.Language, UnitTestingInvocationReasons.DocumentAdded, isLowPriority: false, activeMember: null, EmptyAsyncToken.Instance)); 627pool.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 (2)

65foreach (var group in priorityDocuments.GroupBy(d => d.Project)) 80project, priorityDocuments.WhereAsArray(d => d.Project == project), searchPattern, kinds, cancellationToken).ConfigureAwait(false);

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

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

ExtractClass\ExtractClassWithDialogCodeAction.cs (7)

56=> _service is not null || _document.Project.Solution.Services.GetService<IExtractClassOptionsService>() is not null; 60var extractClassService = _service ?? _document.Project.Solution.Services.GetRequiredService<IExtractClassOptionsService>(); 77_document.Project.Solution, 96_document.Project.CompilationOptions!); 111_document.Project.Id, 119updatedDocument.Project.Solution, 258unformattedSolution = document.WithSyntaxRoot(currentRoot).Project.Solution;

ExtractInterface\AbstractExtractInterfaceService.cs (9)

138var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 152var containingNamespaceDisplay = GetContainingNamespaceDisplay(refactoringResult.TypeToExtractFrom, refactoringResult.DocumentToExtractFrom.Project.CompilationOptions!); 188refactoringResult.DocumentToExtractFrom.Project.Id, 195unformattedInterfaceDocument.Project.Solution, 234var unformattedSolution = documentWithInterface.Project.Solution; 267var service = document.Project.Solution.Services.GetRequiredService<IExtractInterfaceOptionsService>(); 278=> document.Project.Solution.Services.GetService<IExtractInterfaceOptionsService>() is not null; 304formattedSolution = simplifiedDocument.Project.Solution; 348unformattedSolution = document.WithSyntaxRoot(editor.GetChangedRoot()).Project.Solution;

ExtractMethod\MethodExtractor.Analyzer.cs (1)

323this.SyntaxFacts.SupportsTupleDeconstruction(this.SemanticDocument.Document.Project.ParseOptions!);

ExtractMethod\MethodExtractor.cs (2)

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

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

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

261var options = await optionsProvider.GetOptionsAsync(documentSpan.Document.Project.Services, cancellationToken).ConfigureAwait(false); 317var 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)

150document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (2)

40var project = _document.Project; 85_document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (5)

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

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

74_document.Project.Solution,

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (5)

43=> (_service._pickMembersService_forTesting ?? _document.Project.Solution.Services.GetService<IPickMembersService>()) is not null; 47var service = _service._pickMembersService_forTesting ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 65var globalOptions = _document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 70globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(_document.Project.Language, addNullChecksOption.Value); 84var solution = _document.Project.Solution;

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (3)

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

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)

127var compilation = await _document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (4)

56if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 111var globalOptions = document.Project.Solution.Services.GetService<ILegacyGlobalOptionsWorkspaceService>(); 267var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable(document.Project.Language); 281var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(document.Project.Language);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndHashWithDialogCodeAction.cs (5)

44=> (_service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Services.GetService<IPickMembersService>()) is not null; 48var service = _service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 60var solution = _document.Project.Solution; 71_globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(_document.Project.Language, generateOperatorsOption.Value); 76_globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable(_document.Project.Language, implementIEqutableOption.Value);

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (4)

39=> (_service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Services.GetService<IPickMembersService>()) is not null; 43var services = _document.Project.Solution.Services; 77_document.Project.Solution, 87new ApplyChangesOperation(newDocument.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 (4)

312if (newDocument.Project.Language == _semanticDocument.Document.Project.Language) 400return [new ApplyChangesOperation(codeGenResult.Project.Solution)]; 562return [new ApplyChangesOperation(codeGenResult.Project.Solution)];

GenerateType\AbstractGenerateTypeService.State.cs (1)

329if (documentToBeGeneratedIn.Project != document.Project)

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (2)

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

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

37var solution = document.Project.Solution;

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (9)

55project = document.Project; 95var mappingService = document.Project.Solution.Services.GetRequiredService<ISymbolMappingService>(); 129return (document.Project, SymbolAndLineNumberArray.Empty); 144var remapped = remappedProject != document.Project; 222var projectState = document.Project.State; 224var languageGlyph = document.Project.Language switch 228_ => throw ExceptionUtilities.UnexpectedValue(document.Project.Language), 254var destinationDocument = document.Project.Solution.GetDocument(groupSyntaxTree); 582? definition.SourceSpans[0].Document.Project.State

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (3)

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

270var 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 (6)

51if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 255var modifiedSolution = originalDocument.Project.Solution; 260source: methodCallSites.GroupBy(kvp => kvp.Key.Project), 290methodSymbol, document.Project.Solution, progress, 309if (refLocation.Document.Project.Language == document.Project.Language)

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

148var sourceFromMetadataService = temporaryDocument.Project.Services.GetRequiredService<IMetadataAsSourceService>();

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

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

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

69var destinationDocId = _document.Project.Solution.GetDocumentIdsWithFilePath(moveOptions.FilePath).Single(); 74_document.Project.Solution, 106sourceDoc.Project.Solution, 109sourceDoc.Project.Id, 121var memberReferenceLocations = await FindMemberReferencesAsync(newDoc.Project.Solution, newDoc.Project.Id, moveOptions.SelectedMembers, cancellationToken).ConfigureAwait(false); 122var projectToLocations = memberReferenceLocations.ToLookup(loc => loc.location.Document.Project.Id); 123var solutionWithFixedReferences = await RefactorReferencesAsync(projectToLocations, newDoc.Project.Solution, newType, typeArgIndices, cancellationToken).ConfigureAwait(false); 205var projectToLocations = memberReferenceLocations.ToLookup(loc => loc.location.Document.Project.Id);

MoveToNamespace\AbstractMoveToNamespaceService.cs (3)

226var originalSolution = document.Project.Solution; 280var solution = formattedDocument.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)

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

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

112var 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, 109var solution = document.Project.Solution; 163Debug.Assert(priorityDocuments.All(d => projects.Contains(d.Project))); 206using var _ = GetPooledHashSet(priorityDocuments.Select(d => d.Project), out var highPriProjects); 221using var _1 = GetPooledHashSet(priorityDocuments.Where(d => project == d.Project), out var highPriDocs);

NavigateTo\NavigateToSearcher.cs (9)

189var project = _activeDocument.Project; 206var activeProject = _activeDocument.Project; 294processedProjects.Add(_activeDocument.Project); 295result.Add([_activeDocument.Project]); 302if (processedProjects.Add(doc.Project)) 303buffer.Add(doc.Project); 333if (_activeDocument?.Project != null && projectsSet.Contains(_activeDocument.Project)) 338if (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\AbstractPullMemberUpRefactoringProvider.cs (2)

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

PullMemberUp\MembersPuller.cs (5)

96var solution = document.Project.Solution; 98var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 271var solution = document.Project.Solution; 273var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 304var info = codeGenerationService.GetInfo(context, options.GenerationOptions, destinationEditor.OriginalDocument.Project.ParseOptions);

QuickInfo\CommonSemanticQuickInfoProvider.cs (3)

34var services = context.Document.Project.Solution.Services; 53var services = document.Project.Solution.Services; 75var solution = document.Project.Solution;

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

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

Rename\SymbolicRenameInfo.cs (4)

176semanticModel, triggerToken.SpanStart, document.Project.Solution.Services, cancellationToken: cancellationToken).ConfigureAwait(false); 219var solution = document.Project.Solution; 229if (document.Project.IsSubmission) 231var projectIdOfLocation = sourceDocument.Project.Id;

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (4)

161var project = document.Project; 216return originalDocument.Project.Solution; 220var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Services); 351var compilation = await updatedDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

74var rootNamespace = generateTypeService.GetRootNamespace(newDocument.Project.CompilationOptions); 85newDocument.Project.Solution, 128return Formatter.Format(syntaxGenerator.SyntaxGeneratorInternal.TypeParameterList(typeParameterNames), document.Project.Solution.Services, formattingOptions, cancellationToken).ToString();

SignatureHelp\AbstractSignatureHelpProvider.cs (3)

255var totalProjects = relatedDocuments.Concat(document).SelectAsArray(d => d.Project.Id); 286invalidProjectsForCurrentSymbol.Add(relatedDocument.Project.Id); 290var 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)

76var 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\roslyn\src\Analyzers\Core\CodeFixes\AddObsoleteAttribute\AbstractAddObsoleteAttributeCodeFixProvider.cs (1)

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

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

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

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

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

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

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

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

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

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

448document.Project.Solution, 496document.Project.Solution,

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

35_document.Project.Solution,

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

25var languageServices = _document.Project.Solution.GetExtendedLanguageServices(_state.TypeToGenerateIn.Language); 35_document.Project.Solution,

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

32if (context.Document.Project.IsSubmission)

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

65var syntaxFactory = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language).GetService<SyntaxGenerator>(); 73_document.Project.Solution, 89_document.Project.Solution,

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.cs (2)

53var semanticFacts = document.Project.Solution.GetRequiredLanguageService<ISemanticFactsService>(state.TypeToGenerateIn.Language); 59CodeGenerator.CanAdd(document.Project.Solution, state.TypeToGenerateIn, cancellationToken))

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementAbstractClass\ImplementAbstractClassData.cs (2)

54if (!CodeGenerator.CanAdd(document.Project.Solution, classType, cancellationToken)) 85var compilation = await _document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\AbstractImplementInterfaceService.cs (4)

131var supportsImplementingLessAccessibleMember = syntaxFacts.SupportsImplicitImplementationOfNonPublicInterfaceMembers(document.Project.ParseOptions!); 137generateInvisibly: generator.ShouldGenerateInvisibleMember(document.Project.ParseOptions!, interfaceMember, interfaceMember.Name, supportsImplementingLessAccessibleMember), 176var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 178var supportsImplicitImplementationOfNonPublicInterfaceMembers = syntaxFacts.SupportsImplicitImplementationOfNonPublicInterfaceMembers(document.Project.ParseOptions!);

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

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

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

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

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

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

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

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

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\MakeMethodSynchronous\AbstractMakeMethodSynchronousCodeFixProvider.cs (6)

75var solution = document.Project.Solution; 97var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 108var newSolution = newDocument.Project.Solution; 136[methodSymbol], document.Project.Solution, cancellationToken).ConfigureAwait(false); 144document.Project.Solution, [.. referencedSymbol.Locations], cancellationToken).ConfigureAwait(false); 149return document.Project.Solution;

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

27var service = context.Document.Project.Solution.Services.GetRequiredService<ISupportedChangesService>(); 52var targetFolders = PathMetadataUtilities.BuildFoldersFromNamespace(targetNamespace, document.Project.DefaultNamespace); 61var newSolution = await renameActionSet.UpdateSolutionAsync(documentWithInvalidFolders.Project.Solution, cancellationToken).ConfigureAwait(false); 62Debug.Assert(newSolution != document.Project.Solution);

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

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

src\roslyn\src\Analyzers\Core\CodeFixes\RemoveAsyncModifier\AbstractRemoveAsyncModifierCodeFixProvider.cs (2)

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

src\roslyn\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\roslyn\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\roslyn\src\Analyzers\Core\CodeFixes\UpgradeProject\AbstractUpgradeProjectCodeFixProvider.cs (1)

42var project = context.Document.Project;

src\roslyn\src\Analyzers\Core\CodeFixes\UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (11)

85var solution = context.Document.Project.Solution; 130Debug.Assert(fieldDocument.Project == propertyDocument.Project); 131var project = fieldDocument.Project; 171Debug.Assert(fieldDocument.Project == propertyDocument.Project); 173compilation = await fieldDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 230var editor = new SyntaxEditor(declaratorTreeRoot, fieldDocument.Project.Solution.Services); 414Contract.ThrowIfFalse(fieldDocument.Project == propertyDocument.Project); 419var currentProject = currentSolution.GetRequiredProject(fieldDocument.Project.Id);

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

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

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

SyncNamespaces\AbstractSyncNamespacesService.cs (2)

126document.Project, 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,

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

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