Project

AbstractAddObsoleteAttributeCodeFixProvider.cs (1)

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

AbstractChangeNamespaceToMatchFolderCodeFixProvider.cs (4)

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

AbstractConvertToAsyncCodeFixProvider.cs (1)

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

AbstractFileHeaderCodeFixProvider.cs (1)

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

AbstractMakeMethodAsynchronousCodeFixProvider.cs (2)

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

AbstractMakeMethodSynchronousCodeFixProvider.cs (6)

77var solution = document.Project.Solution; 99var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 110var newSolution = newDocument.Project.Solution; 138ImmutableArray.Create<ISymbol>(methodSymbol), document.Project.Solution, cancellationToken).ConfigureAwait(false); 146document.Project.Solution, referencedSymbol.Locations.ToImmutableArray(), cancellationToken).ConfigureAwait(false); 151return document.Project.Solution;

AbstractRemoveAsyncModifierCodeFixProvider.cs (2)

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

AbstractRemoveUnusedValuesCodeFixProvider.cs (3)

292var editor = new SyntaxEditor(root, document.Project.Solution.Services); 842var provider = document.Project.Solution.Services; 914var referencedSymbols = await SymbolFinder.FindReferencesAsync(local, document.Project.Solution, cancellationToken).ConfigureAwait(false);

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

AbstractUpgradeProjectCodeFixProvider.cs (1)

43var project = context.Document.Project;

AbstractUseCollectionInitializerCodeFixProvider.cs (1)

99var subEditor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);

AbstractUseConditionalExpressionCodeFixProvider.cs (3)

62var nestedEditor = new SyntaxEditor(root, document.Project.Solution.Services); 80var provider = document.Project.Solution.Services; 154fallbackOptions.GetOptions(document.Project.Services)?.ConditionalExpressionWrappingLength ??

AbstractUseObjectInitializerCodeFixProvider.cs (1)

100var subEditor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (3)

55var services = _document.Project.Solution.Services; 71var constructorDocument = _document.Project.GetDocument(syntaxTree); 74return Task.FromResult<Solution?>(constructorDocument.WithSyntaxRoot(newRoot).Project.Solution);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (2)

42if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 184priorDocument.Project.Solution, 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);

AddFileBanner\AbstractAddFileBannerCodeRefactoringProvider.cs (1)

73document.Project.Documents

AddImport\AbstractAddImportCodeFixProvider.cs (3)

57var services = document.Project.Solution.Services; 59var codeActionOptions = context.Options.GetOptions(document.Project.Services); 67var packageSources = installerService?.IsEnabled(document.Project.Id) == true

AddImport\AbstractAddImportFeatureService.cs (6)

62var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 66document.Project.Solution, 127var project = document.Project; 513var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 517document.Project.Solution, 596AddImportFixKind.PackageSymbol => installerService?.IsInstalled(document.Project.Id, fixData.PackageName) == false

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (1)

40var newProject = newDocument.Project;

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (2)

61this.OriginalDocument.Project.Solution, cancellationToken).ConfigureAwait(false)); 77return updatedDocument.Project.Solution;

AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs (2)

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

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

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

AddImport\References\ProjectSymbolReference.cs (4)

44return document.Project.Id == _project.Id 59=> document.Project.Id != _project.Id; 68if (document.Project.Id == _project.Id) 100var project = document.Project;

AddImport\SymbolReferenceFinder.cs (1)

94_owner, _document.Project, exact, cancellationToken);

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (1)

98var project = _document.Project;

AddMissingReference\AbstractAddMissingReferenceCodeFixProvider.cs (2)

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

AddPackage\AbstractAddPackageCodeFixProvider.cs (3)

47var workspaceServices = document.Project.Solution.Services; 55context.Options.GetOptions(document.Project.Services).SearchOptions.SearchNuGetPackages && 56installerService.IsEnabled(document.Project.Id))

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

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

AddParameterService.cs (2)

83var solution = invocationDocument.Project.Solution; 151method, invocationDocument.Project.Solution, cancellationToken).ConfigureAwait(false);

AnalyzerOptionsProviders.cs (2)

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

BraceMatching\AbstractEmbeddedLanguageBraceMatcher.cs (1)

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

BraceMatching\BraceMatchingService.cs (1)

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

ChangeSignature\AbstractChangeSignatureService.cs (4)

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

ChangeSignature\ChangeSignatureAnalyzedContext.cs (1)

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

CodeFixes\Configuration\ConfigurationUpdater.cs (2)

274var solution = editorConfigDocument.Project.Solution; 324currentSolution = addedAnalyzerConfigDocument.Project.Solution;

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

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

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

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

CodeFixes\GenerateMember\AbstractGenerateMemberCodeFixProvider.cs (1)

34if (context.Document.Project.IsSubmission)

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

35new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

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

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

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

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

80var currentSolution = triggerDocument.Project.Solution; 81foreach (var grouping in diagnosticsByDocument.GroupBy(d => d.Key.Project)) 95currentSolution = newDocument.Project.Solution; 125currentSolution = newDocument.Project.Solution; 139var services = suppressionsDoc.Project.Solution.Services;

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

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

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

70return 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)

42var suppressionFixes = await _suppressionFixProvider.GetFixesAsync(context.Document.Project, projectDiagnostics, context.Options, context.CancellationToken).ConfigureAwait(false);

CodeLens\CodeLensReferencesService.cs (1)

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

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (9)

57var solution = document.Project.Solution; 73var usableFixes = unambiguousFixes.WhereAsArray(fixData => DoesNotAddReference(fixData, document.Project.Id)); 92var solution = document.Project.Solution; 119var newProject = document.Project; 166var services = document.Project.Solution.Services; 216document.Project.Solution, progressTracker, cancellationToken).ConfigureAwait(false); 220newSolution = document.Project.Solution; 236var projectChanges = newDocument.Project.GetChanges(document.Project);

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsRefactoringProvider.cs (2)

45context.Options.GetOptions(document.Project.Services).HideAdvancedMembers); 64return modifiedDocument.Project.Solution;

CodeRefactorings\CodeRefactoringService.cs (4)

72if (LanguageToProvidersMap.TryGetValue(document.Project.Language, out var lazyProviders)) 82if (document.Project.Solution.WorkspaceKind == WorkspaceKind.Interactive) 98var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 128var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

CodeRefactorings\ExtractMethod\AbstractExtractMethodCodeRefactoringProvider.cs (1)

43var solution = document.Project.Solution;

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

65return document.Project.Solution; 78return modifiedSolution ?? document.Project.Solution;

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

51var projectToBeUpdated = SemanticDocument.Document.Project; 67var solutionWithNewDocument = documentWithMovedType.Project.Solution; 125var projectToBeUpdated = document.Project; 205return updatedDocument.Project.Solution;

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

97return changedDocument.Project.Solution;

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

40var oldSolution = SemanticDocument.Document.Project.Solution;

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

30var solution = SemanticDocument.Document.Project.Solution;

CodeRefactorings\MoveType\MoveTypeCodeRefactoringProvider.cs (1)

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

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (10)

132var solution = document.Project.Solution; 193var solution = document.Project.Solution; 348var solution = document.Project.Solution; 356!PathUtilities.PathsEqual(arg.solution.GetRequiredDocument(id).Project.FilePath!, arg.document.Project.FilePath!), (solution, document))) 471var solutionWithChangedNamespace = documentWithNewNamespace.Project.Solution; 555symbol, document.Project.Solution, progress, documents: null, 631var services = documentWithAddedImports.Project.Solution.Services; 785solution = document.Project.Solution; 846var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

CodeRefactorings\SyncNamespace\AbstractSyncNamespaceCodeRefactoringProvider.cs (1)

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

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

45var solution = _state.Document.Project.Solution; 46var newDocumentId = DocumentId.CreateNewId(document.Project.Id, document.Name); 74var 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)

69var solution = document.Project.Solution;

Completion\CompletionProvider.cs (2)

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

Completion\CompletionService.cs (5)

101var languageServices = document?.Project.Services ?? _services.GetLanguageServices(Language); 105var passThroughOptions = options ?? document?.Project.Solution.Options ?? OptionSet.Empty; 107return ShouldTriggerCompletion(document?.Project, languageServices, text, caretPosition, trigger, completionOptions, passThroughOptions, roles); 196var provider = GetProvider(item, document.Project); 222var provider = GetProvider(item, document.Project);

Completion\CompletionService_GetCompletions.cs (5)

45var passThroughOptions = options ?? document.Project.Solution.Options; 102var providers = _providerManager.GetFilteredProviders(document.Project, roles, trigger, options); 161if (ShouldTriggerCompletion(document.Project, document.Project.Services, text, caretPosition, trigger, options, passThroughOptions, roles)) 163var triggeredProviders = providers.Where(p => p.ShouldTriggerCompletion(document.Project.Services, text, caretPosition, trigger, options, passThroughOptions)).ToImmutableArrayOrEmpty();

Completion\Providers\AbstractAggregateEmbeddedLanguageCompletionProvider.cs (1)

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

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (4)

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

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (2)

41var globalOptions = document.Project.Solution.Services.GetService<ILegacyGlobalCleanCodeGenerationOptionsWorkspaceService>(); 144document.Project.Solution,

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

23var solution = originatingDocument.Project.Solution;

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (2)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

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

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

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

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

133var globalOptions = document.Project.Solution.Services.GetService<ILegacyGlobalCleanCodeGenerationOptionsWorkspaceService>(); 141var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 218var solution = document.Project.Solution;

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

33typeImportCompletionService.QueueCacheWarmUpTask(document.Project); 44completionContext.Document.Project,

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

58var project = document.Project; 121var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

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

51_cacheService = GetCacheService(document.Project); 99foreach (var peReference in GetAllRelevantPeReferences(_originatingDocument.Project)) 107foreach (var project in GetAllRelevantProjects(_originatingDocument.Project)) 142GetCacheService(_originatingDocument.Project).WorkQueue.AddWork(_originatingDocument.Project); 188return project == _originatingDocument.Project 202_originatingDocument.Project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false);

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

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

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

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

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

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

Completion\Providers\SymbolCompletionItem.cs (8)

131var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 142var linkedDoc = document.Project.Solution.GetRequiredDocument(id); 143var linkedCompilation = await linkedDoc.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 193var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 197var services = document.Project.Solution.Services; 208return document.Project.Solution.GetRequiredDocument(contextId); 358var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 362return await CommonCompletionUtilities.CreateDescriptionAsync(document.Project.Solution.Services, semanticModel, position, symbols, options, supportedPlatforms, cancellationToken).ConfigureAwait(false);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

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

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

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

ConvertIfToSwitch\AbstractConvertIfToSwitchCodeRefactoringProvider.cs (1)

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

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

ConvertToInterpolatedString\ConvertRegularStringToInterpolatedStringRefactoringProvider.cs (1)

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

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (8)

214var solution = document.Project.Solution; 251return document.WithSyntaxRoot(newRoot).Project.Solution; 325foreach (var group in documentsToUpdate.GroupBy(d => d.Document.Project)) 420document.Project, tupleType, cancellationToken).ConfigureAwait(false), 422document.Project, tupleType, cancellationToken).ConfigureAwait(false), 516var solution = startingDocument.Project.Solution; 578var currentSolution = startingDocument.Project.Solution; 599currentSolution = updatedDocument.Project.Solution;

DesignerAttribute\DesignerAttributeDiscoveryService.cs (2)

83await ProcessProjectAsync(priorityDocument.Project, priorityDocument, useFrozenSnapshots, callback, cancellationToken).ConfigureAwait(false); 126project = document.WithFrozenPartialSemantics(cancellationToken).Project;

DocumentHighlighting\AbstractDocumentHighlightsService.cs (8)

39var solution = document.Project.Solution; 41var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 47document.Project, 71var solution = document.Project.Solution; 124symbol, document.Project.Solution, progress, 164var solution = startingDocument.Project.Solution; 182if (currentDocument.Project.Language == startingDocument.Project.Language)

DocumentSpanExtensions.cs (1)

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

EditAndContinue\CommittedSolution.cs (3)

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

EditAndContinue\DebuggingSession.cs (5)

460var project = document.Project; 649if (!document.Project.SupportsEditAndContinue()) 777if (_isDisposed || !EditSession.InBreakState || !mappedDocument.State.SupportsEditAndContinue() || !mappedDocument.Project.SupportsEditAndContinue()) 784var newProject = mappedDocument.Project; 960var analyzer = newDocument.Project.Services.GetRequiredService<IEditAndContinueAnalyzer>();

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (4)

86var oldProject = oldDocument?.Project ?? oldSolution.GetRequiredProject(newDocument.Project.Id); 138var analyzer = newDocument.Project.Services.GetRequiredService<IEditAndContinueAnalyzer>(); 196var analyzer = document.Project.Services.GetRequiredService<IEditAndContinueAnalyzer>();

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (2)

262if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 274document.Project.Solution,

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (6)

175if (!RemoteSupportedLanguages.IsSupported(document.Project.Language)) 188diagnostic => RemapLocation(designTimeDocument, DiagnosticData.Create(document.Project.Solution, diagnostic, document.Project))); 195document.Project.Solution, 205var project = document.Project; 223diagnostic = await data.ToDiagnosticAsync(document.Project, cancellationToken).ConfigureAwait(false);

EditAndContinue\TraceLog.cs (3)

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

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

41AddEmbeddedLanguageClassifications(document.Project, semanticModel, textSpan, options, result, cancellationToken);

EncapsulateField\AbstractEncapsulateFieldService.cs (9)

112var solution = document.Project.Solution; 143var currentSolution = document.Project.Solution; 180var solution = document.Project.Solution; 219solution = document.Project.Solution; 226solution = updatedLinkedDocument.Project.Solution; 249document, document.Project.Solution, field, generatedProperty, fallbackOptions, cancellationToken).ConfigureAwait(false); 254return documentWithProperty.Project.Solution; 265var projectId = document.Project.Id; 279var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

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

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

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

606await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, UnitTestingInvocationReasons.DocumentChanged).ConfigureAwait(false); 617await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 644list.Add(new UnitTestingWorkItem(document.Id, document.Project.Language, UnitTestingInvocationReasons.DocumentAdded, isLowPriority: false, activeMember: null, EmptyAsyncToken.Instance)); 722pool.Object.Add(document.Project.Language);

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

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

ExternalAccess\VSTypeScript\VSTypeScriptDocumentDiagnosticAnalyzer.cs (2)

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

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

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

ExtractClass\ExtractClassWithDialogCodeAction.cs (6)

66var extractClassService = _service ?? _document.Project.Solution.Services.GetRequiredService<IExtractClassOptionsService>(); 84_document.Project.Solution, 102_document.Project.CompilationOptions); 118_document.Project.Id, 127updatedDocument.Project.Solution, 266unformattedSolution = document.WithSyntaxRoot(currentRoot).Project.Solution;

ExtractInterface\AbstractExtractInterfaceService.cs (10)

143var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 157var containingNamespaceDisplay = GetContainingNamespaceDisplay(refactoringResult.TypeToExtractFrom, refactoringResult.DocumentToExtractFrom.Project.CompilationOptions); 193refactoringResult.DocumentToExtractFrom.Project.Id, 201unformattedInterfaceDocument.Project.Solution, 242var unformattedSolution = documentWithInterface.Project.Solution; 275var notificationService = document.Project.Solution.Services.GetService<INotificationService>(); 279var service = document.Project.Solution.Services.GetService<IExtractInterfaceOptionsService>(); 288document.Project.Language, 317formattedSolution = simplifiedDocument.Project.Solution; 361unformattedSolution = document.WithSyntaxRoot(editor.GetChangedRoot()).Project.Solution;

ExtractMethod\ExtractMethodResult.cs (1)

98var services = DocumentWithoutFinalFormatting.Project.Solution.Services;

ExtractMethod\MethodExtractor.Analyzer.cs (3)

351var syntaxFactsService = _semanticDocument.Document.Project.Services.GetService<ISyntaxFactsService>(); 592var semanticFacts = _semanticDocument.Document.Project.Services.GetRequiredService<ISemanticFactsService>(); 915var semanticFacts = _semanticDocument.Document.Project.Services.GetRequiredService<ISemanticFactsService>();

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

44var options = await _context.GetOptionsAsync(document.Project.Language, cancellationToken).ConfigureAwait(false);

FindUsages\AbstractFindUsagesService_FindReferences.cs (2)

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

FindUsages\DefinitionItem.cs (1)

229new TaggedText(TextTags.Text, firstDocument.Project.Name));

FindUsages\FindUsagesHelpers.cs (1)

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

FindUsages\IDefinitionsAndReferencesFactory.cs (2)

205var options = await context.GetOptionsAsync(documentSpan.Document.Project.Language, cancellationToken).ConfigureAwait(false); 257var options = await context.GetOptionsAsync(document.Project.Language, cancellationToken).ConfigureAwait(false);

FullyQualify\AbstractFullyQualifyCodeFixProvider.cs (1)

25var hideAdvancedMembers = context.Options.GetOptions(document.Project.Services).HideAdvancedMembers;

FullyQualify\AbstractFullyQualifyService.cs (4)

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

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

153document.Project.Solution,

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs (2)

51var project = _document.Project; 95_document.Project.Solution,

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (4)

109priorDocument.Project.Solution, codeAction, cancellationToken).ConfigureAwait(false); 155if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 234var globalOptions = document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 235var optionValue = globalOptions.GetGenerateConstructorFromMembersOptionsAddNullChecks(document.Project.Language);

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs (1)

81_document.Project.Solution,

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (4)

60var service = _service._pickMembersService_forTesting ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 82var globalOptions = _document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 83globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(_document.Project.Language, addNullChecksOption.Value); 99var solution = _document.Project.Solution;

GenerateDefaultConstructors\AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs (1)

49_document.Project.Solution,

GenerateDefaultConstructors\GenerateDefaultConstructorsCodeRefactoringProvider.cs (2)

42if (document.Project.IsSubmission) 45if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles)

GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (3)

44var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); 66var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); 123var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)

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

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (5)

58if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 262var globalOptions = document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 263var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable(document.Project.Language); 277var globalOptions = document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>(); 278var value = globalOptions.GetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(document.Project.Language);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndHashWithDialogCodeAction.cs (4)

59var service = _service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Services.GetRequiredService<IPickMembersService>(); 70var solution = _document.Project.Solution; 83globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersGenerateOperators(_document.Project.Language, generateOperatorsOption.Value); 88globalOptions.SetGenerateEqualsAndGetHashCodeFromMembersImplementIEquatable(_document.Project.Language, implementIEqutableOption.Value);

GenerateMember\GenerateConstructor\AbstractGenerateConstructorService.State.cs (5)

582var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); 601document.Project.Solution, 617var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); 640var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); 650document.Project.Solution,

GenerateMember\GenerateEnumMember\AbstractGenerateEnumMemberService.CodeAction.cs (2)

36var languageServices = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language); 46_document.Project.Solution,

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.CodeAction.cs (3)

70var syntaxFactory = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language).GetService<SyntaxGenerator>(); 78_document.Project.Solution, 95_document.Project.Solution,

GenerateMember\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.cs (1)

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

GenerateMember\GenerateVariable\AbstractGenerateVariableService.cs (2)

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

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (3)

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

GenerateType\AbstractGenerateTypeService.CodeAction.cs (4)

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

GenerateType\AbstractGenerateTypeService.Editor.cs (4)

318if (newDocument.Project.Language == _semanticDocument.Document.Project.Language) 407return new CodeActionOperation[] { new ApplyChangesOperation(codeGenResult.Project.Solution) }; 572return new CodeActionOperation[] { new ApplyChangesOperation(codeGenResult.Project.Solution) };

GenerateType\AbstractGenerateTypeService.State.cs (1)

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

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (2)

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

ImplementAbstractClass\AbstractImplementAbstractClassCodeFixProvider.cs (1)

42document, classNode, GetClassIdentifier(classNode), context.Options.GetImplementTypeGenerationOptions(document.Project.Services), cancellationToken).ConfigureAwait(false);

ImplementAbstractClass\ImplementAbstractClassData.cs (2)

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

ImplementInterface\AbstractImplementInterfaceService.CodeAction.cs (2)

195var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 210document.Project.Solution,

ImplementInterface\AbstractImplementInterfaceService.CodeAction_Property.cs (1)

167var generator = Document.Project.Services.GetRequiredService<SyntaxGenerator>();

ImplementInterface\AbstractImplementInterfaceService.DisposePatternCodeAction.cs (4)

132var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 334var configOptions = document.Project.AnalyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree); 341var fallbackFormattingOptions = await ((OptionsProvider<SyntaxFormattingOptions>)Options.FallbackOptions).GetOptionsAsync(document.Project.Services, cancellationToken).ConfigureAwait(false); 356var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

ImplementInterface\AbstractImplementInterfaceService.State.cs (1)

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

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

49var solution = document.Project.Solution;

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (9)

57project = document.Project; 90var mappingService = document.Project.Solution.Services.GetRequiredService<ISymbolMappingService>(); 116return (document.Project, SymbolAndLineNumberArray.Empty); 131var remapped = remappedProject != document.Project; 209var projectState = document.Project.State; 211var languageGlyph = document.Project.Language switch 215_ => throw ExceptionUtilities.UnexpectedValue(document.Project.Language), 241var destinationDocument = document.Project.Solution.GetDocument(groupSyntaxTree); 555? definition.SourceSpans[0].Document.Project.State

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (2)

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

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (4)

399var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 453var services = document.Project.Solution.Services; 504var currentSolution = document.Project.Solution; 739var compilation = await document.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

47var globalOptions = document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>();

InlineHints\AbstractInlineTypeHintsService.cs (1)

43var globalOptions = document.Project.Solution.Services.GetRequiredService<ILegacyGlobalOptionsWorkspaceService>();

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

337var solution = document.Project.Solution;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

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

InlineTemporary\AbstractInlineTemporaryCodeRefactoringProvider.cs (1)

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

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (6)

49if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles) 235var modifiedSolution = originalDocument.Project.Solution; 239foreach (var (project, projectCallSites) in methodCallSites.GroupBy(kvp => kvp.Key.Project)) 261methodSymbol, document.Project.Solution, progress, 280if (refLocation.Document.Project.Language == document.Project.Language)

IntroduceVariable\IntroduceVariableCodeRefactoringProvider.cs (1)

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

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

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

MetadataAsSource\AbstractMetadataAsSourceService.cs (1)

44document.Project.Solution,

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

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

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

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

MetadataAsSource\SymbolMappingServiceFactory.cs (1)

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

MoveStaticMembers\AbstractMoveStaticMembersRefactoringProvider.cs (1)

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

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (9)

80var destinationDocId = _document.Project.Solution.GetDocumentIdsWithFilePath(moveOptions.FileName).Single(); 84sourceDoc.Project.Solution, 111sourceDoc.Project.Solution, 114_document.Project.Id, 127var memberReferenceLocations = await FindMemberReferencesAsync(moveOptions.SelectedMembers, newDoc.Project.Solution, cancellationToken).ConfigureAwait(false); 128var projectToLocations = memberReferenceLocations.ToLookup(loc => loc.location.Document.Project.Id); 129var solutionWithFixedReferences = await RefactorReferencesAsync(projectToLocations, newDoc.Project.Solution, newType, typeArgIndices, cancellationToken).ConfigureAwait(false); 185oldSolution = newTypeDoc.WithSyntaxRoot(newTypeRoot).Project.Solution; 189var projectToLocations = memberReferenceLocations.ToLookup(loc => loc.location.Document.Project.Id);

MoveToNamespace\AbstractMoveToNamespaceService.cs (3)

227var originalSolution = document.Project.Solution; 289var solution = formattedDocument.Project.Solution; 319var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

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

NamingStyleCodeFixProvider.cs (2)

95document.Project.Solution, 110document.Project.Solution, symbol, new SymbolRenameOptions(), fixedName,

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (2)

211var solution = document.Project.Solution; 221result.Add(linkedDocument.Project.Id);

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (4)

29var solution = document.Project.Solution; 32var client = await RemoteHostClient.TryGetClientAsync(document.Project, cancellationToken).ConfigureAwait(false); 38document.Project, 52document.Project, priorityDocuments: ImmutableArray<Document>.Empty, document,

NavigateTo\NavigateToSearcher.cs (7)

149var project = _activeDocument.Project; 235processedProjects.Add(_activeDocument.Project); 236result.Add(ImmutableArray.Create(_activeDocument.Project)); 243if (processedProjects.Add(doc.Project)) 244buffer.Add(doc.Project); 271if (_activeDocument?.Project == project) 276if (doc.Project == project)

NavigateTo\RoslynNavigateToItem.cs (2)

152var firstProject = _itemDocument.Project; 181return _itemDocument.Project.Name;

NavigationBar\AbstractNavigationBarItemService.cs (2)

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

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (2)

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

PullMemberUp\MembersPuller.cs (5)

102var solution = document.Project.Solution; 104var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 281var solution = document.Project.Solution; 283var codeGenerationService = document.Project.Services.GetRequiredService<ICodeGenerationService>(); 314var info = codeGenerationService.GetInfo(context, options.GenerationOptions, destinationEditor.OriginalDocument.Project.ParseOptions);

QuickInfo\CommonSemanticQuickInfoProvider.cs (4)

31var services = context.Document.Project.Solution.Services; 59var services = document.Project.Solution.Services; 81var solution = document.Project.Solution; 87var candidateProjects = new List<ProjectId> { document.Project.Id };

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

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

Rename\SymbolicRenameInfo.cs (4)

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

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

169var project = document.Project; 224var editor = new SyntaxEditor(root, originalDocument.Project.Solution.Services); 356var compilation = await updatedDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (2)

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

Shared\Extensions\DocumentExtensions.cs (2)

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

Shared\Utilities\AnnotatedSymbolMapping.cs (1)

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

Shared\Utilities\ExtractTypeHelpers.cs (3)

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

SignatureHelp\AbstractSignatureHelpProvider.cs (4)

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

Snippets\AbstractSnippetService.cs (1)

66foreach (var provider in _lazySnippetProviders.Where(p => p.Metadata.Language == document.Project.Language))

Snippets\SnippetProviders\AbstractConsoleSnippetProvider.cs (1)

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

SolutionCrawler\AbstractDocumentDifferenceService.cs (1)

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

SolutionCrawler\WorkCoordinator.cs (6)

267() => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentOpened), _shutdownToken); 273() => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken); 543await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, InvocationReasons.DocumentChanged).ConfigureAwait(false); 550await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 577list.Add(new WorkItem(document.Id, document.Project.Language, InvocationReasons.DocumentAdded, isLowPriority: false, activeMember: null, EmptyAsyncToken.Instance)); 655pool.Object.Add(document.Project.Language);

SolutionCrawler\WorkCoordinator.SemanticChangeProcessor.cs (2)

138EnqueueFullProjectDependency(document.Project, assembly); 175var solution = thisDocument.Project.Solution;

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (2)

121HideAdvancedMembers = context.Options.GetOptions(document.Project.Services).HideAdvancedMembers, 128var passThroughOptions = document.Project.Solution.Options;

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

SyncNamespaces\AbstractSyncNamespacesService.cs (2)

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

TaskList\AbstractTaskListService.cs (2)

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

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (9)

75var solution = context.Document.Project.Solution; 86Debug.Assert(fieldDocument.Project == propertyDocument.Project); 87var project = fieldDocument.Project; 150Debug.Assert(fieldDocument.Project == propertyDocument.Project); 152compilation = await fieldDocument.Project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false); 209var editor = new SyntaxEditor(declaratorTreeRoot, fieldDocument.Project.Solution.Services); 288return Formatter.Format(newRoot, SpecializedFormattingAnnotation, document.Project.Solution.Services, options, formattingRules, cancellationToken);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (1)

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

ValueTracking\ValueTracker.cs (3)

27var operationCollector = new OperationCollector(progressCollector, document.Project.Solution); 37var solution = document.Project.Solution; 69await progressCollector.TryReportAsync(document.Project.Solution, node.GetLocation(), symbol, cancellationToken).ConfigureAwait(false);

ValueTracking\ValueTrackingService.cs (2)

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

Workspace\CompileTimeSolutionProvider.cs (2)

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

Wrapping\AbstractWrappingCodeRefactoringProvider.cs (1)

49var options = GetWrappingOptions(configOptions, context.Options.GetOptions(document.Project.Services));