Solution

Workspace\Solution\Project.cs (1)

CodeRefactoringRunner.cs (2)

95document.Project.Solution, CodeAnalysisProgress.None, cancellationToken).ConfigureAwait(false); 103var changes = applyChangesOperation.ChangedSolution.GetChanges(document.Project.Solution);

RegexClassifierBenchmarks.cs (1)

84var extensionManager = document.Project.Solution.Services.GetService<IExtensionManager>();

ProjectOperationBenchmarks.cs (1)

107var solution = Project.Solution;

CallAnalysis\Fixers\LegacyLoggingFixer.cs (3)

281return (proj.Solution, cl, proj.GetDocument(cl.SyntaxTree)!); 470var solEditor = new SolutionEditor(doc.Project.Solution); 580var solEditor = new SolutionEditor(targetDoc.Project.Solution);

Resources\RoslynTestUtils.cs (2)

66Assert.True(proj.Solution.Workspace.TryApplyChanges(proj.Solution));

Resources\RoslynTestUtils.cs (2)

66Assert.True(proj.Solution.Workspace.TryApplyChanges(proj.Solution));

TestDiagnosticAnalyzer.cs (3)

32var doc = project.Solution.GetDocument(project.Documents.First().Id); 49var doc = project.Solution.GetDocument(project.Documents.First().Id); 71var document = project.Solution.GetDocument(project.Documents.First().Id);

Helpers\CodeFixVerifier.Helper.cs (1)

82root = Formatter.Format(root, Formatter.Annotation, simplifiedDoc.Project.Solution.Workspace);

Verifiers\CodeFixVerifier.cs (1)

109document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));

Helpers\CodeFixVerifier.Helper.cs (1)

82root = Formatter.Format(root, Formatter.Annotation, simplifiedDoc.Project.Solution.Workspace);

Verifiers\CodeFixVerifier.cs (1)

109document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));

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

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

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

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

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

605document.Project.Solution, 651document.Project.Solution,

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

51_document.Project.Solution,

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

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

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

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

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

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

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

90var solution = _project.Solution; 128var solution = _project.Solution;

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

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

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

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

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

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

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

96this.Document.Project.Solution,

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

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

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

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

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

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

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

45fixAllContext.Project.Solution,

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

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

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

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

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

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

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

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

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

44var solution = project.Solution;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\DocumentExtensions.cs (3)

98var workspace = document.Project.Solution.Workspace; 163var semanticModelService = document.Project.Solution.Services.GetRequiredService<ISemanticModelReuseWorkspaceService>(); 219var solution = document.Project.Solution;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (2)

38=> project.Solution.Workspace.Services.GetExtendedLanguageServices(project.Language); 91var solutionOrProjectFilePath = project.Solution?.FilePath ?? project.FilePath;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\TextDocumentExtensions.cs (2)

51return textDocument.Project.Solution.WithAdditionalDocumentText(textDocument.Id, text, PreservationMode.PreserveIdentity).GetTextDocument(textDocument.Id)!; 60return textDocument.Project.Solution.WithAnalyzerConfigDocumentText(textDocument.Id, text, PreservationMode.PreserveIdentity).GetTextDocument(textDocument.Id)!;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

91var findReferencesResult = await SymbolFinder.FindReferencesAsync(LocalSymbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

13=> project.Solution.Services.GetRequiredService<ISupportedChangesService>().CanApplyParseOptionChange(oldOptions, newOptions, project);

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)

91var solutionEditor = new SolutionEditor(document.Project.Solution);

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

105var editor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (3)

35var syntaxEditor = new SyntaxEditor(root, document.Project.Solution.Services); 54localFunctionSymbol, document.Project.Solution, documentImmutableSet, cancellationToken).ConfigureAwait(false); 126capture, document.Project.Solution, documentImmutableSet, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UpdateProjectToAllowUnsafe\CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs (1)

43return project.Solution.WithProjectCompilationOptions(project.Id, compilationOptions.WithAllowUnsafe(true));

src\Analyzers\CSharp\CodeFixes\UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs (2)

95return project.Solution.WithProjectParseOptions(project.Id, parseOptions.WithLanguageVersion(parsedNewVersion)); 100return project.Solution;

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForArrayCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

74var subEditor = new SyntaxEditor(root, document.Project.Solution.Services);

src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

109document.Project.Solution.Services, currentRoot,

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (2)

95var solutionEditor = new SolutionEditor(document.Project.Solution); 111var solution = document.Project.Solution;

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (2)

67var solutionEditor = new SolutionEditor(document.Project.Solution); 82var solution = document.Project.Solution;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs (1)

44var editor = new SyntaxEditor(memberDeclaration, document.Project.Solution.Services);

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (3)

171var factory = document.Project.Solution.Workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 196var workspace = document.Project.Solution.Workspace; 246var newSolution = document.Project.Solution.WithDocumentText(formattedDocument.Id, newText);

EventHookup\EventHookupCommandHandler_TypeCharCommand.cs (1)

50if (document != null && document.Project.Solution.Workspace.CanApplyChange(ApplyChangesKind.ChangeDocument))

Formatting\CSharpFormattingInteractionService.cs (1)

89return Task.FromResult(Formatter.GetFormattedTextChanges(parsedDocument.Root, [formattingSpan], document.Project.Solution.Services, options, cancellationToken).ToImmutableArray());

StringCopyPaste\StringCopyPasteCommandHandler.cs (1)

216var copyPasteService = documentBeforePaste.Project.Solution.Services.GetRequiredService<IStringCopyPasteService>();

StringCopyPaste\StringCopyPasteCommandHandler_CutCopy.cs (1)

58var copyPasteService = document.Project.Solution.Services.GetService<IStringCopyPasteService>();

CodeActions\ApplyChangesOperationTests.cs (1)

36var codeAction = new TestCodeAction(_changeSolution(context.Document.Project.Solution));

CodeActions\MoveType\MoveTypeTests.MoveScope.cs (2)

928Assert.NotEqual(documentToModify.Project.Solution, modifiedSolution); 932Assert.Equal(documentToModify.Project.Solution, modifiedSolution);

CodeActions\PreviewExceptionTests.cs (1)

114extensionManager = document.Project.Solution.Services.GetService<IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;

CodeActions\PreviewTests.cs (1)

70var solution = _oldDocument.Project.Solution;

Completion\CompletionProviders\OverrideCompletionProviderTests.cs (2)

3192await workspace.ChangeSolutionAsync(updatedP1.Solution); 3246await workspace.ChangeSolutionAsync(updatedProject.Solution);

Completion\CompletionServiceTests.cs (1)

210Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged));

Formatting\CodeCleanupTests.cs (2)

813project = project.Solution.WithProjectFilePath(project.Id, @$"z:\\{project.FilePath}").GetProject(project.Id); 815workspace.TryApplyChanges(project.Solution);

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (2)

127using var workspace = (EditorTestWorkspace)project.Solution.Workspace; 266var compilationFactory = project.Solution.Services.GetRequiredLanguageService<ICompilationFactoryService>(LanguageNames.CSharp);

Workspaces\WorkspaceTests_EditorFeatures.cs (4)

1310workspace.TryApplyChanges(doc.Project.Solution); 1317workspace.TryApplyChanges(project.RemoveAdditionalDocument(doc.Id).Solution); 1338workspace.TryApplyChanges(doc.Project.Solution); 1345workspace.TryApplyChanges(project.RemoveAnalyzerConfigDocument(doc.Id).Solution);

ChangeSignature\CSharpChangeSignatureService.cs (1)

874convertedType = await SymbolFinder.FindSourceDefinitionAsync(convertedType, document.Project.Solution, cancellationToken).ConfigureAwait(false)

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (1)

71var solution = project.Solution;

CodeRefactorings\SyncNamespace\CSharpChangeNamespaceService.cs (2)

44if (document.Project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles 70document.Project.Solution, allDocumentIds, containerSpan, cancellationToken).ConfigureAwait(false);

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

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

Completion\CompletionProviders\SnippetCompletionProvider.cs (3)

83var solution = document.Project.Solution; 143completionContext, document.Project.Solution.Services, semanticModel, isPreProcessorContext: true); 159completionContext, document.Project.Solution.Services, semanticModel, isPreProcessorContext: false);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)

92var solution = document.Project.Solution;

EncapsulateField\CSharpEncapsulateFieldService.cs (1)

107document.Project.Solution,

Formatting\CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs (1)

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

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

213var solution = project.Solution;

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

43var solution = project.Solution;

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider_Update.cs (3)

45var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 85var solution = project.Solution; 207var solution = project.Solution;

NavigationBar\CSharpNavigationBarItemService.cs (1)

53return GetMembersInTypes(document.Project.Solution, tree, typesInFile, cancellationToken);

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (1)

134var hostAnalyzers = document.Project.Solution.SolutionState.Analyzers;

ReverseForStatement\CSharpReverseForStatementCodeRefactoringProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)

91var solutionEditor = new SolutionEditor(document.Project.Solution);

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

105var editor = new SyntaxEditor(currentRoot, document.Project.Solution.Services);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (3)

35var syntaxEditor = new SyntaxEditor(root, document.Project.Solution.Services); 54localFunctionSymbol, document.Project.Solution, documentImmutableSet, cancellationToken).ConfigureAwait(false); 126capture, document.Project.Solution, documentImmutableSet, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\NewLines\EmbeddedStatementPlacement\EmbeddedStatementPlacementCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\RemoveConfusingSuppression\CSharpRemoveConfusingSuppressionCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UpdateProjectToAllowUnsafe\CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs (1)

43return project.Solution.WithProjectCompilationOptions(project.Id, compilationOptions.WithAllowUnsafe(true));

src\Analyzers\CSharp\CodeFixes\UpgradeProject\CSharpUpgradeProjectCodeFixProvider.cs (2)

95return project.Solution.WithProjectParseOptions(project.Id, parseOptions.WithLanguageVersion(parsedNewVersion)); 100return project.Solution;

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForArrayCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UseCollectionExpression\CSharpUseCollectionExpressionForBuilderCodeFixProvider.cs (1)

74var subEditor = new SyntaxEditor(root, document.Project.Solution.Services);

src\Analyzers\CSharp\CodeFixes\UseDeconstruction\CSharpUseDeconstructionCodeFixProvider.cs (1)

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

src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (1)

109document.Project.Solution.Services, currentRoot,

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (2)

95var solutionEditor = new SolutionEditor(document.Project.Solution); 111var solution = document.Project.Solution;

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (2)

67var solutionEditor = new SolutionEditor(document.Project.Solution); 82var solution = document.Project.Solution;

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (2)

45AddDocument("test.cs", SourceText.From(source, Encoding.UTF8), filePath: Path.Combine(TempRoot.Root, "test.cs")).Project.Solution; 464AddDocument("test.cs", root, filePath: Path.Combine(TempRoot.Root, "test.cs")).Project.Solution;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpReplaceDiscardDeclarationsWithAssignmentsService.cs (1)

44var editor = new SyntaxEditor(memberDeclaration, document.Project.Solution.Services);

CodeGeneration\SymbolEditorTests.cs (1)

45return ws.AddProject(proj).Solution;

Formatting\FormattingTreeEditTests.cs (2)

46var result1 = Formatter.Format(root1, document.Project.Solution.Services, options, CancellationToken.None); 59var result2 = Formatter.Format(root2, document.Project.Solution.Services, options, CancellationToken.None);

AddImports\AbstractAddImportsPasteCommandHandler.cs (2)

137var indicatorFactory = document.Project.Solution.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 166document.Project.Solution.Workspace.TryApplyChanges(updatedDocument.Project.Solution);

ChangeSignature\AbstractChangeSignatureCommandHandler.cs (1)

97HandleResult(result, document.Project.Solution, workspace, context);

CodeDefinitionWindow\DefinitionContextTracker.cs (3)

145var workspace = document.Project.Solution.Workspace; 155var text = await item.Document.GetTextAsync(document.Project.Solution, cancellationToken).ConfigureAwait(false); 174var definitionItem = symbol.ToNonClassifiedDefinitionItem(document.Project.Solution, includeHiddenLocations: false);

CommentSelection\AbstractCommentSelectionBase.cs (1)

154var formattedChanges = Formatter.GetFormattedTextChanges(newRoot, formattingSpans, document.Project.Solution.Services, formattingOptions, rules: default, cancellationToken);

EditAndContinue\ActiveStatementTrackingService.cs (2)

170var compileTimeSolution = _compileTimeSolutionProvider.GetCompileTimeSolution(designTimeDocument.Project.Solution); 354var solution = document.Project.Solution;

EditAndContinue\PdbMatchingSourceTextProvider.cs (1)

86var oldSolutionVersion = oldDocument.Project.Solution.WorkspaceVersion;

EncapsulateField\AbstractEncapsulateFieldCommandHandler.cs (2)

67var workspace = initialDocument.Project.Solution.Workspace; 107var solution = document.Project.Solution;

Extensibility\NavigationBar\AbstractEditorNavigationBarItemService.cs (1)

48var workspace = document.Project.Solution.Workspace;

ExternalAccess\IntelliCode\IntentProcessor.cs (2)

93newSolution = await newSolution.WithMergedLinkedFileChangesAsync(originalDocument.Project.Solution, cancellationToken: cancellationToken).ConfigureAwait(false); 99var docChanges = await GetTextChangesForDocumentAsync(newSolution, currentDocument.Project.Solution, changedDocumentId, cancellationToken).ConfigureAwait(false);

ExternalAccess\VSTypeScript\VSTypeScriptNavigationBarItemService.cs (1)

59var workspace = document.Project.Solution.Workspace;

ExtractInterface\AbstractExtractInterfaceCommandHandler.cs (1)

79if (!document.Project.Solution.Workspace.TryApplyChanges(result.UpdatedSolution))

ExtractMethod\ExtractMethodCommandHandler.cs (2)

120var indicatorFactory = document.Project.Solution.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 197var notificationService = document.Project.Solution.Services.GetService<INotificationService>();

Formatting\FormatCommandHandler.cs (1)

72var ruleFactory = document.Project.Solution.Services.GetRequiredService<IHostDependentFormattingRuleFactoryService>();

Formatting\FormatCommandHandler.Paste.cs (1)

67var solution = document.Project.Solution;

GoToDefinition\AbstractGoToCommandHandler`2.cs (2)

191document.Project.Solution.Workspace, 262var service = document.Project.Solution.Services.GetRequiredService<IWorkspaceStatusService>();

GoToDefinition\GoToDefinitionCommandHandler.cs (2)

107var indicatorFactory = document.Project.Solution.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>(); 145var notificationService = document.Project.Solution.Services.GetRequiredService<INotificationService>();

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (3)

135var solution = this.Document.Project.Solution; 157this.Document.Project.Solution.CanApplyChange(ApplyChangesKind.ChangeDocumentInfo)) 167var symbolSourceDocument = this.Document.Project.Solution.GetDocument(RenameSymbol.Locations.Single().SourceTree);

InlineRename\InlineRenameService.cs (2)

108document.Project.Solution.Workspace, 128var workspace = document.Project.Solution.Workspace;

InlineRename\InlineRenameSession.cs (1)

187_baseSolution = TriggerDocument.Project.Solution;

InlineRename\InlineRenameSession.OpenTextBufferManager.cs (2)

571var textDiffService = oldDocument.Project.Solution.Services.GetService<IDocumentTextDifferencingService>(); 589var textDiffService = preMergeDocument.Project.Solution.Services.GetService<IDocumentTextDifferencingService>();

IntelliSense\AsyncCompletion\CompletionSource.cs (3)

169document.Project, document.Project.Services, sourceText, triggerLocation.Position, roslynTrigger, options, document.Project.Solution.Options, _roles); 394document, triggerLocation, options, document.Project.Solution.Options, roslynTrigger, _roles, cancellationToken).ConfigureAwait(false); 536var supportedPlatforms = SymbolCompletionItem.GetSupportedPlatforms(roslynItem, document.Project.Solution);

Intents\DeleteParameterIntentProvider.cs (1)

62var changedDocuments = changeSignatureResult.UpdatedSolution.GetChangedDocuments(priorDocument.Project.Solution).ToImmutableArray();

Interactive\InteractiveSession.cs (2)

232solution = initProject.Solution.AddDocument( 239solution = newSubmissionProject.Solution.AddDocument(

Navigation\AbstractDefinitionLocationService.cs (2)

32var solution = document.Project.Solution; 127var solution = project.Solution;

NavigationBar\NavigationBarController.cs (1)

251workspace: d.Project.Solution.Workspace,

Preview\AbstractPreviewFactoryService.cs (6)

289using var rightWorkspace = new ReferenceCountedDisposable<PreviewWorkspace>(new PreviewWorkspace(document.Project.Solution)); 371using var leftWorkspace = new ReferenceCountedDisposable<PreviewWorkspace>(new PreviewWorkspace(document.Project.Solution)); 486var leftSolution = oldDocument.Project.Solution; 493var rightSolution = newDocument.Project.Solution; 553using var leftWorkspace = new ReferenceCountedDisposable<PreviewWorkspace>(new PreviewWorkspace(oldDocument.Project.Solution)); 556using var rightWorkspace = new ReferenceCountedDisposable<PreviewWorkspace>(new PreviewWorkspace(newDocument.Project.Solution));

RenameTracking\RenameTrackingCancellationCommandHandler.cs (1)

43RenameTrackingDismisser.DismissVisibleRenameTracking(document.Project.Solution.Workspace, document.Id);

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCodeAction.cs (1)

99_document.Project.Solution.Services.GetService<INotificationService>()

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCommitter.cs (2)

129var workspace = document.Project.Solution.Workspace; 198var solution = document.Project.Solution;

RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (2)

220var sourceSymbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, _cancellationToken).ConfigureAwait(false) ?? symbol; 234var sourceSymbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, _cancellationToken).ConfigureAwait(false) ?? symbol;

SpellCheck\RoslynSpellCheckFixerProvider.cs (1)

109var workspace = document.Project.Solution.Workspace;

Structure\AbstractStructureTaggerProvider.cs (1)

75if (openDocument.Project.Solution.Workspace is MetadataAsSourceWorkspace masWorkspace &&

Completion\AbstractCompletionProviderTests.cs (3)

514document.Project.Solution.Workspace.TryApplyChanges(newDoc.Project.Solution); 1058var isTextualTriggerCharacterResult = service.ShouldTriggerCompletion(document.Project, document.Project.Services, text, position + 1, trigger, options, document.Project.Solution.Options, GetRoles(document));

Diagnostics\GenerateType\GenerateTypeTestState.cs (2)

67return (TestGenerateTypeOptionsService)InvocationDocument.Project.Solution.Services.GetRequiredService<IGenerateTypeOptionsService>(); 75return (TestProjectManagementService)InvocationDocument.Project.Solution.Services.GetService<IProjectManagementService>();

Diagnostics\GenerateType\TestGenerateTypeOptionsService.cs (1)

55DefaultNamespace ??= projectManagementService.GetDefaultNamespace(Project, Project?.Solution.Workspace);

ExtractInterface\ExtractInterfaceTestState.cs (1)

70return (TestExtractInterfaceOptionsService)ExtractFromDocument.Project.Solution.Services.GetService<IExtractInterfaceOptionsService>();

LanguageServer\AbstractLanguageServerProtocolTests.cs (2)

428.Solution; 440.Solution;

CodeFixes\CodeFixServiceTests.cs (6)

406extensionManager = (EditorLayerExtensionManager.ExtensionManager)document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 892var solution = await codeAction.GetChangedSolutionInternalAsync(txtDocument.Project.Solution, CodeAnalysisProgress.None); 950return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); 1070var appliedChanges = workspace.TryApplyChanges(sourceDocument.Project.Solution); 1081sourceDocument.Project.Solution, sourceDocument.Project.Id, sourceDocument.Id, diagnosticIds: null, shouldIncludeAnalyzer: null, getDocuments: null, 1145var cachedDiagnostics = await diagnosticIncrementalAnalyzer.GetCachedDiagnosticsAsync(sourceDocument.Project.Solution, sourceDocument.Project.Id, sourceDocument.Id,

CodeRefactorings\CodeRefactoringServiceTest.cs (5)

108var extensionManager = (EditorLayerExtensionManager.ExtensionManager)document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 180var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None); 219var solution = await codeAction.GetChangedSolutionInternalAsync(project.Solution, CodeAnalysisProgress.None); 248return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); 249return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (5)

177var applied = workspace.TryApplyChanges(document.Project.Solution); 404var incrementalAnalyzer = service.CreateIncrementalAnalyzer(project.Solution.Workspace); 444var applied = workspace.TryApplyChanges(project.Solution); 749workspace.TryApplyChanges(project.Solution); 859Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(new TestGeneratorReference(generator)).Solution));

Diagnostics\DiagnosticDataTests.cs (3)

228secondDocument = firstDocument.Project.Solution.AddProject("TestProject2", "TestProject2", LanguageNames.CSharp) 236firstDocument = secondDocument.Project.Solution.GetRequiredDocument(firstDocument.Id); 260firstDocument = firstDocument.Project.Solution

LinkedFiles\LinkedFileDiffMergingEditorTests.cs (2)

103var linkedDocument = document.Project.Solution.Projects.Single(p => p != document.Project).Documents.Single(); 107var newSolution = document.Project.Solution

Preview\PreviewWorkspaceTests.cs (6)

56Assert.True(previewWorkspace.TryApplyChanges(project.Solution)); 70Assert.True(previewWorkspace.TryApplyChanges(project.Solution)); 74.AddDocument("document", "").Project.Solution; 80var changedSolution = previewWorkspace.CurrentSolution.Projects.First().Documents.First().WithText(SourceText.From(text)).Project.Solution; 86.RemoveDocument(previewWorkspace.CurrentSolution.Projects.First().DocumentIds[0]).Solution; 102Assert.True(previewWorkspace.TryApplyChanges(document.Project.Solution));

TextEditor\OpenDocumentTests.cs (2)

64Assert.Same(workspace.CurrentSolution, newDocumentWithChanges.Project.Solution); 70Assert.NotSame(workspace.CurrentSolution, originalDocumentWithChanges.Project.Solution);

InlineDiagnostics\AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs (1)

107var workspace = project.Solution.Workspace;

NavigableSymbols\NavigableSymbolService.NavigableSymbolSource.cs (1)

49var indicatorFactory = document.Project.Solution.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>();

Peek\PeekableItemFactory.cs (1)

62var solution = project.Solution;

Peek\PeekableItemSource.cs (3)

75var services = document.Project.Solution.Services; 127var workspace = project.Solution.Workspace; 136var text = await document.GetTextAsync(project.Solution, cancellationToken).ConfigureAwait(false);

QuickInfo\ContentControlService.cs (1)

70var workspace = new PreviewWorkspace(document.Project.Solution);

QuickInfo\Extensions.cs (1)

39var cloneServices = document.Project.Solution.Services.ExportProvider.GetExports<ITextBufferCloneService>();

SignatureHelp\Controller.cs (1)

134_providers = document.Project.Solution.Services.SelectMatchingExtensionValues(

Suggestions\SuggestedActionsSource_Async.cs (1)

211var workspace = document.Project.Solution.Workspace;

Suggestions\SuggestedActionWithNestedFlavors.cs (1)

52originalDocument.Project.Solution,

Diagnostics\DiagnosticServiceTests.vb (1)

1427Dim descriptorsMap = project.Solution.SolutionState.Analyzers.GetDiagnosticDescriptorsPerReference(diagnosticService.AnalyzerInfoCache, project)

FindReferences\FindReferencesTests.vb (1)

387Function(g) GetFilePathAndProjectLabel(document.Project.Solution, g.Key),

Internal\Editor\FSharpNavigationBarItemService.cs (1)

69var workspace = document.Project.Solution.Workspace;

Completion\OmniSharpCompletionService.cs (2)

25return completionService.ShouldTriggerCompletion(document.Project, document.Project.Services, text, caretPosition, trigger, options.ToCompletionOptions(), document.Project.Solution.Options, roles); 37return completionService.GetCompletionsAsync(document, caretPosition, options.ToCompletionOptions(), document.Project.Solution.Options, trigger, roles, cancellationToken);

GoToDefinition\OmniSharpFindDefinitionService.cs (1)

25document.Project.Solution,

Cohost\Handlers\CodeActions.cs (2)

25var solution = document.Project.Solution; 46var solution = document.Project.Solution;

Cohost\Handlers\Completion.cs (2)

38var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>(); 60var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>();

Cohost\Handlers\Diagnostics.cs (2)

20var globalOptionsService = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>(); 21var diagnosticAnalyzerService = document.Project.Solution.Services.ExportProvider.GetService<IDiagnosticAnalyzerService>();

Cohost\Handlers\DocumentHighlights.cs (2)

19var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>(); 20var highlightingService = document.Project.Solution.Services.ExportProvider.GetService<IHighlightingService>();

Cohost\Handlers\FoldingRanges.cs (1)

19var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>();

Cohost\Handlers\GoToDefinition.cs (2)

20var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>(); 21var metadataAsSourceFileService = document.Project.Solution.Services.ExportProvider.GetService<IMetadataAsSourceFileService>();

Cohost\Handlers\GoToImplementation.cs (1)

20var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>();

Cohost\Handlers\Hover.cs (1)

23var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>();

Cohost\Handlers\OnAutoInsert.cs (2)

22var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>(); 23var services = document.Project.Solution.Services.ExportProvider.GetExports<IBraceCompletionService, LanguageMetadata>().Where(s => s.Metadata.Language == LanguageNames.CSharp).SelectAsArray(s => s.Value);

Cohost\Handlers\SignatureHelp.cs (1)

18var signatureHelpService = document.Project.Solution.Services.ExportProvider.GetService<SignatureHelpService>();

RazorClassifierAccessor.cs (1)

20document.Project.Solution.Services, document.Project, semanticModel, textSpan, options.UnderlyingObject, cancellationToken);

RazorSpanMappingServiceWrapper.cs (1)

36var diffService = newDocument.Project.Solution.Services.GetRequiredService<IDocumentTextDifferencingService>();

Internal\DescriptionService.cs (1)

66var services = project.Solution.Services;

Internal\LocationService.cs (3)

49var items = NavigableItemFactory.GetItemsFromPreferredSourceLocations(project.Solution, symbol, displayTaggedParts: null, cancellationToken); 54var document = await item.Document.GetRequiredDocumentAsync(project.Solution, cancellationToken).ConfigureAwait(false); 64var declarationFile = await _metadataAsSourceFileService.GetGeneratedFileAsync(project.Solution.Workspace, project, symbol, signaturesOnly: true, options: options, cancellationToken: cancellationToken).ConfigureAwait(false);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (2)

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

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (1)

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

AddDebuggerDisplay\AbstractAddDebuggerDisplayCodeRefactoringProvider.cs (1)

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

AddImport\AbstractAddImportCodeFixProvider.cs (1)

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

AddImport\AbstractAddImportFeatureService.cs (7)

72document.Project.Solution, 135var projectToAssembly = new ConcurrentDictionary<Project, AsyncLazy<IAssemblySymbol>>(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count); 136var referenceToCompilation = new ConcurrentDictionary<PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count)); 162=> project.Solution.WorkspaceKind is WorkspaceKind.Host or WorkspaceKind.RemoteWorkspace; 319var solution = project.Solution; 449var solution = project.Solution; 539document.Project.Solution,

AddImport\CodeActions\AssemblyReferenceCodeAction.cs (2)

46var operation = new ApplyChangesOperation(newProject.Solution); 101return new ApplyChangesOperation(newProject.Solution);

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (2)

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

AddImport\CodeActions\MetadataSymbolReferenceCodeAction.cs (2)

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

AddImport\CodeActions\ProjectSymbolReferenceCodeAction.cs (1)

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

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

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

AddImport\SearchScopes\MetadataSymbolsSearchScope.cs (1)

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

AddImport\SearchScopes\SourceSymbolsProjectSearchScope.cs (1)

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

AddMissingReference\AddMissingReferenceCodeAction.cs (2)

31var dependencyGraph = project.Solution.GetProjectDependencyGraph(); 52var candidateProject = project.Solution.GetRequiredProject(candidateProjectId);

AddPackage\AbstractAddPackageCodeFixProvider.cs (1)

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

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

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

ChangeSignature\AbstractChangeSignatureService.cs (2)

109symbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false) ?? symbol; 163var solution = document.Project.Solution;

ChangeSignature\ChangeSignatureAnalyzedContext.cs (1)

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

CodeFixes\Configuration\ConfigurationUpdater.cs (8)

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

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

37new ApplyChangesOperation(changedSuppressionDocument.Project.Solution),

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

73var currentSolution = triggerDocument.Project.Solution; 102var currentSolution = triggerProject.Solution;

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

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

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

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

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

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

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (5)

62var solution = document.Project.Solution; 100var solution = document.Project.Solution; 174var services = document.Project.Solution.Services; 224document.Project.Solution, progressTracker, cancellationToken).ConfigureAwait(false); 228newSolution = document.Project.Solution;

CodeRefactorings\CodeRefactoringService.cs (2)

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

CodeRefactorings\MoveType\AbstractMoveTypeService.cs (2)

64return document.Project.Solution; 77return modifiedSolution ?? document.Project.Solution;

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

63var solutionWithNewDocument = documentWithMovedType.Project.Solution; 140var solutionWithNewDocument = projectToBeUpdated.Solution.AddDocument( 198return updatedDocument.Project.Solution;

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

91return changedDocument.Project.Solution;

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (4)

134var solution = document.Project.Solution; 194var solution = document.Project.Solution; 347var solution = document.Project.Solution; 553symbol, document.Project.Solution, progress, documents: null,

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

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

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

171var solution = document.Project.Solution;

Completion\CompletionOptions.cs (1)

79var solution = document.Project.Solution;

Completion\CompletionProvider.cs (1)

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

Completion\CompletionService.cs (2)

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

Completion\CompletionService.ProviderManager.cs (1)

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

Completion\CompletionService_GetCompletions.cs (3)

48var passThroughOptions = options ?? document.Project.Solution.Options; 155var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 329var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>();

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (2)

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

Completion\Providers\AbstractMemberInsertingCompletionProvider.cs (1)

141document.Project.Solution,

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

22var solution = originatingDocument.Project.Solution;

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (2)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

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

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

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

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

76var solution = currentProject.Solution;

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

61=> project.Solution.Services.GetRequiredService<IImportCompletionCacheService<ExtensionMethodImportCompletionCacheEntry, object>>(); 83await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false); 144var graph = project.Solution.GetProjectDependencyGraph(); 146return relevantProjectIds.Select(project.Solution.GetRequiredProject).Where(p => p.SupportsCompilation).ToImmutableArray(); 208_originatingDocument.Project.Solution, peReference, checksum: null, cancellationToken).ConfigureAwait(false);

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

147document.Project.Solution.Services,

Completion\Providers\SymbolCompletionItem.cs (6)

152var linkedDoc = document.Project.Solution.GetRequiredDocument(id); 203var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 207var services = document.Project.Solution.Services; 218return document.Project.Solution.GetRequiredDocument(contextId); 363var supportedPlatforms = GetSupportedPlatforms(item, document.Project.Solution); 367return await CommonCompletionUtilities.CreateDescriptionAsync(document.Project.Solution.Services, semanticModel, position, symbols, options, supportedPlatforms, cancellationToken).ConfigureAwait(false);

ConvertAutoPropertyToFullProperty\AbstractConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

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

ConvertForEachToFor\AbstractConvertForEachToForCodeRefactoringProvider.cs (1)

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

ConvertLinq\ConvertForEachToLinqQuery\AbstractConvertForEachToLinqQueryProvider.cs (1)

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

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (5)

193var hostServices = document.Project.Solution.Services 223var solution = document.Project.Solution; 438var solution = startingProject.Solution; 524var solution = startingDocument.Project.Solution; 586var currentSolution = startingDocument.Project.Solution;

DesignerAttribute\DesignerAttributeDiscoveryService.cs (2)

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

DocumentHighlighting\AbstractDocumentHighlightsService.cs (4)

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

DocumentSpanExtensions.cs (1)

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

EditAndContinue\DebuggingSession.cs (1)

778var newSolution = newProject.Solution;

EditAndContinue\EditSession.cs (2)

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

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (1)

167document.Project.Solution,

EmbeddedLanguages\Classification\AbstractEmbeddedLanguageClassificationService.cs (1)

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

EncapsulateField\AbstractEncapsulateFieldService.cs (5)

117var solution = document.Project.Solution; 145var currentSolution = document.Project.Solution; 181var solution = document.Project.Solution; 221document, document.Project.Solution, field, generatedProperty, cancellationToken).ConfigureAwait(false); 226return documentWithProperty.Project.Solution;

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

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

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

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

ExtractClass\AbstractExtractClassRefactoringProvider.cs (1)

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

ExtractInterface\AbstractExtractInterfaceService.cs (4)

139var solution = refactoringResult.DocumentToExtractFrom.Project.Solution; 266var notificationService = document.Project.Solution.Services.GetService<INotificationService>(); 270var service = document.Project.Solution.Services.GetService<IExtractInterfaceOptionsService>(); 351unformattedSolution = document.WithSyntaxRoot(editor.GetChangedRoot()).Project.Solution;

ExtractMethod\MethodExtractor.cs (2)

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

FindUsages\AbstractFindUsagesService_FindImplementations.cs (2)

43var solution = project.Solution; 75var solution = project.Solution;

FindUsages\AbstractFindUsagesService_FindReferences.cs (5)

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

FindUsages\FindUsagesHelpers.cs (1)

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

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

152document.Project.Solution,

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (1)

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

GenerateOverrides\GenerateOverridesWithDialogCodeAction.cs (2)

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

GenerateType\AbstractGenerateTypeService.CodeAction.cs (3)

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

GenerateType\AbstractGenerateTypeService.Editor.cs (3)

70Contract.ThrowIfFalse(document.Project.Solution == generateTypeOptionsResult.Project.Solution); 273var newSolution = projectToBeUpdated.Solution.AddDocument(newDocumentId, documentName, string.Empty, folders, fullFilePath); 350var updatedSolution = projectToBeUpdated.Solution.AddDocument(

GoToBase\AbstractGoToBaseService.cs (1)

45var solution = project.Solution;

GoToDefinition\AbstractGoToDefinitionSymbolService.cs (1)

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

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

36var solution = document.Project.Solution;

InheritanceMargin\AbstractInheritanceMarginService_Helpers.cs (3)

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

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (1)

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

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (3)

381var currentSolution = document.WithSyntaxRoot(trackedRoot).Project.Solution; 433var services = document.Project.Solution.Services; 484var currentSolution = document.Project.Solution;

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

337var solution = document.Project.Solution;

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

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

InlineTemporary\AbstractInlineTemporaryCodeRefactoringProvider.cs (1)

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

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (2)

241var modifiedSolution = originalDocument.Project.Solution; 276methodSymbol, document.Project.Solution, progress,

InvertConditional\AbstractInvertConditionalCodeRefactoringProvider.cs (1)

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

MetadataAsSource\AbstractMetadataAsSourceService.cs (1)

35document.Project.Solution,

MetadataAsSource\MetadataAsSourceGeneratedFileInfo.cs (1)

37: sourceProject.Solution.Services.GetLanguageServices(LanguageName).GetRequiredService<ISyntaxTreeFactoryService>().GetDefaultParseOptionsWithLatestLanguageVersion();

MetadataAsSource\SymbolMappingServiceFactory.cs (1)

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

MoveToNamespace\AbstractMoveToNamespaceService.cs (1)

223var originalSolution = document.Project.Solution;

NameTupleElement\AbstractNameTupleElementCodeRefactoringProvider.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (1)

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

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (1)

27var solution = document.Project.Solution;

NavigateTo\RoslynNavigateToItem.cs (1)

148var solution = firstProject.Solution;

Navigation\INavigableItem.cs (1)

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

PullMemberUp\MembersPuller.cs (2)

95var solution = document.Project.Solution; 270var solution = document.Project.Solution;

RelatedDocuments\AbstractRelatedDocumentsService.cs (1)

70var solution = document.Project.Solution;

RemoveUnusedVariable\AbstractRemoveUnusedVariableCodeFixProvider.cs (1)

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

Rename\SymbolicRenameInfo.cs (2)

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

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (3)

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

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (2)

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

SemanticSearch\SemanticSearchUtilities.cs (1)

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

Shared\Extensions\DocumentExtensions.cs (2)

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

Shared\Utilities\ExtractTypeHelpers.cs (1)

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

SignatureHelp\AbstractSignatureHelpProvider.cs (1)

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

SignatureHelp\SignatureHelpService.cs (1)

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

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (1)

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

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

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

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

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

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

605document.Project.Solution, 651document.Project.Solution,

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

51_document.Project.Solution,

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

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

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

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

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

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

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

90var solution = _project.Solution; 128var solution = _project.Solution;

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

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

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

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

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

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

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

96this.Document.Project.Solution,

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

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

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

77var solution = document.Project.Solution; 110var newSolution = newDocument.Project.Solution; 151return document.Project.Solution;

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

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

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

45fixAllContext.Project.Solution,

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

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

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

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

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

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

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

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

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

44var solution = project.Solution;

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

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

SymbolMapping\SymbolMappingResult.cs (1)

23public Solution Solution => Project.Solution;

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

40var solution = projects[0].Solution;

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (2)

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

ValueTracking\ValueTracker.cs (3)

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

ValueTracking\ValueTrackingService.cs (1)

36var solution = document.Project.Solution;

Diagnostics\TestDiagnosticAnalyzerDriver.cs (2)

52project.Solution, project.Id, document.Id, diagnosticIds: null, shouldIncludeAnalyzer: null, 65project.Solution, project.Id, documentId: null, diagnosticIds: null, shouldIncludeAnalyzer: null,

EditAndContinue\EditAndContinueTestVerifier.cs (1)

456var newSolution = oldProject.Solution;

EditAndContinue\EditAndContinueWorkspaceTestBase.cs (3)

95solution = project.Solution; 125solution = document.Project.Solution; 129return document.Project.Solution;

EditAndContinue\Extensions.cs (1)

71=> project.Solution.AddTestDocument(project.Id, source, path, out id);

EditAndContinue\ActiveStatementsMapTests.cs (3)

118.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 173.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution; 224.AddDocument("doc", SourceText.From(source, Encoding.UTF8), filePath: "a.cs").Project.Solution;

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (4)

235solution = document.Project.Solution; 572solution = project.Solution; 766solution = project.Solution; 1141solution = project.Solution;

EditAndContinue\EditSessionActiveStatementsTests.cs (2)

72solution = project.Solution; 176solution = dummyProject.Solution.AddDocument(DocumentId.CreateNewId(dummyProject.Id, NoCompilationConstants.LanguageName), "a.dummy", "");

EditAndContinue\EmitSolutionUpdateResultsTests.cs (1)

73var solution = document.Project.Solution;

LanguageServer\Handler\DebugConfiguration\WorkspaceDebugConfigurationHandler.cs (1)

50return new ProjectDebugConfiguration(project.FilePath!, project.OutputFilePath!, GetProjectName(project), targetsDotnetCore, isExe, project.Solution.FilePath);

Extensions\Extensions.cs (1)

158var solution = documents.First().Project.Solution;

Extensions\ProtocolConversions.cs (1)

819IsMiscellaneous = project.Solution.WorkspaceKind == WorkspaceKind.MiscellaneousFiles,

Extensions\ProtocolConversions.Diagnostics.cs (1)

119var informationService = project.Solution.Services.GetRequiredService<IDiagnosticProjectInformationService>();

ExternalAccess\Razor\FormatNewFileHandler.cs (1)

88root = Formatter.Format(root, project.Solution.Services, syntaxFormattingOptions, cancellationToken);

Features\CodeCleanup\AbstractCodeCleanupService.cs (3)

188var fixAllService = document.Project.Solution.Services.GetRequiredService<IFixAllGetFixesService>(); 250var solutionChanges = updatedDocument.Project.Solution.GetChanges(currentDocument.Project.Solution);

Features\CodeFixes\CodeFixService.cs (9)

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

46var solution = document.Project.Solution; 65var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(project.Solution, project.Id, documentId: null, _diagnosticIds, shouldIncludeAnalyzer: null, _includeSuppressedDiagnostics, includeLocalDocumentDiagnostics: true, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false); 72var diagnostics = await _diagnosticService.GetProjectDiagnosticsForIdsAsync(project.Solution, project.Id, _diagnosticIds, shouldIncludeAnalyzer: null, _includeSuppressedDiagnostics, includeNonLocalDocumentDiagnostics: false, cancellationToken).ConfigureAwait(false);

Features\Diagnostics\DiagnosticAnalyzerService.cs (2)

90var analyzer = CreateIncrementalAnalyzer(document.Project.Solution.Workspace); 109var analyzer = CreateIncrementalAnalyzer(project.Solution.Workspace);

Features\Diagnostics\DocumentAnalysisExecutor.cs (1)

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

Features\Diagnostics\DocumentAnalysisExecutor_Helpers.cs (2)

388foreach (var documentId in project.Solution.GetDocumentIdsWithFilePath(path)) 428var documentIds = targetTextDocument.Project.Solution.GetDocumentIdsWithFilePath(lineSpan.Path);

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.Executor.cs (1)

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

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs (3)

96var options = project.Solution.Services.GetRequiredService<IWorkspaceConfigurationService>().Options; 101project.Solution, 256project.Solution,

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.ProjectState.cs (1)

219&& project.Solution.Services.GetService<ISolutionCrawlerOptionsService>()?.EnableDiagnosticsInSourceGeneratedFiles == true)

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs (3)

35var key = new HostAnalyzerStateSetKey(project.Language, project.State.HasSdkCodeStyleAnalyzers, project.Solution.SolutionState.Analyzers.HostAnalyzerReferences); 39var hostStateSets = ImmutableInterlocked.GetOrAdd(ref _hostAnalyzerStateMap, key, CreateLanguageSpecificAnalyzerMap, (project.Solution.SolutionState.Analyzers, referenceIdsToRedirect)); 88return GetFeaturesAnalyzerReferenceIds(project.Solution.SolutionState.Analyzers);

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.StateManager.ProjectStates.cs (1)

82var hostAnalyzers = project.Solution.SolutionState.Analyzers;

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnostics.cs (1)

183var document = await project.Solution.GetTextDocumentAsync(

Features\EditAndContinue\EditAndContinueDiagnosticSource_OpenDocument.cs (1)

27var designTimeSolution = designTimeDocument.Project.Solution;

Features\Options\BlockStructureOptionsStorage.cs (1)

12=> GetBlockStructureOptions(globalOptions, project.Language, isMetadataAsSource: project.Solution.WorkspaceKind == WorkspaceKind.MetadataAsSource);

Features\UnifiedSuggestions\UnifiedSuggestedActionsSource.cs (3)

43var originalSolution = document.Project.Solution; 511var originalSolution = document.Project.Solution; 600var originalSolution = document.Project.Solution;

Handler\CodeActions\CodeActionFixAllResolveHandler.cs (1)

61var operations = await fixAllCodeAction.GetOperationsAsync(document.Project.Solution, CodeAnalysisProgress.None, cancellationToken).ConfigureAwait(false);

Handler\CodeActions\CodeActionHelpers.cs (2)

393document.Project.Solution.Workspace, codeFixService, document, textSpan, 398document.Project.Solution.Workspace, codeRefactoringService, document, textSpan, priority: null,

Handler\CodeActions\CodeActionResolveHandler.cs (1)

77var solution = document.Project.Solution;

Handler\CodeLens\CodeLensResolveHandler.cs (2)

67var codeLensReferencesService = document.Project.Solution.Services.GetRequiredService<ICodeLensReferencesService>(); 68var referenceCount = await codeLensReferencesService.GetReferenceCountAsync(document.Project.Solution, document.Id, memberToResolve.Node, maxSearchResults: 99, cancellationToken).ConfigureAwait(false);

Handler\Completion\CompletionHandler.cs (2)

93&& !completionService.ShouldTriggerCompletion(project, project.Services, documentText, position, completionTrigger, completionOptions, project.Solution.Options, roles: null)) 176var completionList = await completionService.GetCompletionsAsync(document, position, completionOptions, document.Project.Solution.Options, completionTrigger, cancellationToken: cancellationToken).ConfigureAwait(false);

Handler\Definitions\AbstractGoToDefinitionHandler.cs (1)

68await definition.Document.GetRequiredDocumentAsync(document.Project.Solution, cancellationToken).ConfigureAwait(false),

Handler\Diagnostics\DiagnosticSources\AbstractWorkspaceDocumentDiagnosticSource.cs (1)

77Document.Project.Solution, Document.Project.Id, documentId: null,

Handler\Diagnostics\DiagnosticSources\NonLocalDocumentDiagnosticSource.cs (1)

28Document.Project.Solution, Document.Project.Id, Document.Id,

Handler\Formatting\AbstractFormatDocumentHandlerBase.cs (1)

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

Handler\InlineCompletions\InlineCompletionsHandler.cs (1)

186var formattingChanges = Formatter.GetFormattedTextChanges(root, spanToFormat, originalDocument.Project.Solution.Services, formattingOptions, cancellationToken: cancellationToken)

Handler\PullHandlers\VersionedPullCache.cs (3)

80var workspace = project.Solution.Workspace; 83var isFullyLoaded = await IsFullyLoadedAsync(project.Solution, cancellationToken).ConfigureAwait(false); 86var cacheEntry = _idToLastReportedResult.GetOrAdd((project.Solution.Workspace, projectOrDocumentId), (_) => new CacheItem(uniqueKey));

Handler\Rename\RenameHandler.cs (1)

36var oldSolution = document.Project.Solution;

Handler\SemanticTokens\SemanticTokensRefreshQueue.cs (1)

44var projectChecksum = await project.Solution.CompilationState.GetChecksumAsync(project.Id, cancellationToken).ConfigureAwait(false);

Handler\SourceGenerators\SourceGeneratedDocumentGetTextHandler.cs (1)

41document = await document.Project.Solution.WithoutFrozenSourceGeneratedDocuments().GetDocumentAsync(document.Id, includeSourceGenerated: true, cancellationToken).ConfigureAwait(false);

Workspaces\LspWorkspaceManager.cs (2)

291var workspaceKind = document.Project.Solution.WorkspaceKind; 304return (workspace, document.Project.Solution, document);

Workspaces\LspWorkspaceManagerTests.cs (6)

447await testWorkspaceTwo.ChangeProjectAsync(newProjectWorkspaceTwo.Id, newProjectWorkspaceTwo.Solution); 503await testWorkspace.ChangeProjectAsync(newProject.Id, newProject.Solution); 709Assert.Same(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution); 726Assert.NotSame(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution); 742Assert.Same(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution); 750Assert.NotSame(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution);

Host\RemoteWorkspace.SolutionCreator.cs (8)

426return project.Solution; 501project = addDocuments(project.Solution, lazyDocumentsToAdd.ToImmutable()).GetProject(project.Id)!; 518project = removeDocuments(project.Solution, lazyDocumentsToRemove.ToImmutable()).GetProject(project.Id)!; 562TextDocumentKind.Document => document.Project.Solution.WithDocumentTextLoader(document.Id, loader, mode).GetRequiredDocument(document.Id), 563TextDocumentKind.AnalyzerConfigDocument => document.Project.Solution.WithAnalyzerConfigDocumentTextLoader(document.Id, loader, mode).GetRequiredAnalyzerConfigDocument(document.Id), 564TextDocumentKind.AdditionalDocument => document.Project.Solution.WithAdditionalDocumentTextLoader(document.Id, loader, mode).GetRequiredAdditionalDocument(document.Id), 588document = document.Project.Solution.WithDocumentFolders(document.Id, newDocumentInfo.Folders).GetDocument(document.Id)!; 595document = document.Project.Solution.WithDocumentSourceCodeKind(document.Id, newDocumentInfo.SourceCodeKind).GetDocument(document.Id)!;

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (2)

106_performanceTracker = project.Solution.Services.GetService<IPerformanceTrackerService>(); 578foreach (var reference in _project.Solution.AnalyzerReferences)

Services\SemanticClassification\RemoteSemanticClassificationService.Caching.cs (1)

116var solution = document.Project.Solution;

Services\SemanticClassification\RemoteSemanticClassificationService.cs (1)

39solution = document.Project.Solution;

SolutionAssetStorage.cs (1)

58=> StoreAssetsAsync(project.Solution.CompilationState, project.Id, cancellationToken);

NonSourceFileRefactoring.cs (2)

30return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); 31return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText);

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (2)

102Dim innerEditor = New SyntaxEditor(root, document.Project.Solution.Services) 136Dim editor = New SyntaxEditor(root, document.Project.Solution.Services)

LineCommit\CommitBufferManager.vb (1)

311Dim refProject = project.Solution.GetProject(reference.ProjectId)

LineCommit\CommitCommandHandler.vb (1)

243Dim formattingRuleService = document.Project.Solution.Services.GetService(Of IHostDependentFormattingRuleFactoryService)()

NavigationBar\VisualBasicEditorNavigationBarItemService.vb (1)

48Dim destinationDocument = document.Project.Solution.GetDocument(navigationLocation.documentId)

NavigationBar\VisualBasicEditorNavigationBarItemService_CodeGeneration.vb (4)

145document.Project.Solution, 200document.Project.Solution, 244document.Project.Solution, 271document.Project.Solution,

ChangeSignature\VisualBasicChangeSignatureService.vb (2)

704convertedType = If(Await SymbolFinder.FindSourceDefinitionAsync(convertedType, document.Project.Solution, cancellationToken).ConfigureAwait(False), convertedType) 723nodeType = If(Await SymbolFinder.FindSourceDefinitionAsync(nodeType, document.Project.Solution, cancellationToken).ConfigureAwait(False), nodeType)

CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb (13)

CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.AddKeywordAction.vb (1)

75Dim services = document.Project.Solution.Services

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (2)

33If document.Project.Solution.WorkspaceKind = WorkspaceKind.MiscellaneousFiles Then 185Return Simplifier.Expand(DirectCast(n, StatementSyntax), semanticModel, document.Project.Solution.Services, cancellationToken:=cancellationToken)

NavigationBar\VisualBasicNavigationBarItemService.vb (1)

55document.Project.Solution, type, position, semanticModel, workspaceSupportsDocumentChanges, symbolDeclarationService, cancellationToken))

src\Analyzers\VisualBasic\CodeFixes\RemoveUnnecessaryCast\VisualBasicRemoveUnnecessaryCastCodeFixProvider.vb (2)

102Dim innerEditor = New SyntaxEditor(root, document.Project.Solution.Services) 136Dim editor = New SyntaxEditor(root, document.Project.Solution.Services)

CodeCleanup\Providers\NormalizeModifiersOrOperatorsCodeCleanupProvider.vb (1)

37Dim newRoot = Await CleanupAsync(root, spans, options.FormattingOptions, document.Project.Solution.Services, cancellationToken).ConfigureAwait(False)

CodeCleanup\Providers\RemoveUnnecessaryLineContinuationCodeCleanupProvider.vb (1)

40Dim newRoot = Await CleanupAsync(root, spans, options.FormattingOptions, document.Project.Solution.Services, cancellationToken).ConfigureAwait(False)

Classification\AbstractClassificationService.cs (3)

83var workspaceStatusService = document.Project.Solution.Services.GetRequiredService<IWorkspaceStatusService>(); 191var extensionManager = document.Project.Solution.Services.GetRequiredService<IExtensionManager>(); 205AddSyntacticClassifications(document.Project.Solution.Services, root, textSpans, result, cancellationToken);

Classification\Classifier.cs (1)

35return GetClassifiedSpans(document.Project.Solution.Services, document.Project, semanticModel, textSpan, ClassificationOptions.Default, cancellationToken);

Classification\SemanticClassificationCacheUtilities.cs (1)

23var projectKey = new ProjectKey(SolutionKey.ToSolutionKey(project.Solution), project.Id, project.FilePath, project.Name, Checksum.Null);

CodeActions\CodeAction.cs (2)

332return changedDocument?.Project.Solution; 354return changedDocument?.Project.Solution;

CodeActions\CodeAction_Cleanup.cs (1)

112document.Project.Solution,

CodeActions\Operations\ApplyChangesOperation.cs (2)

127var originalDocument = changedProject.OldProject.Solution.GetRequiredTextDocument(documentId); 128var changedDocument = changedProject.NewProject.Solution.GetRequiredTextDocument(documentId);

CodeFixes\CodeFix.cs (1)

79return DiagnosticData.Create(Project.Solution, diagnostic, Project);

CodeFixes\FixAllOccurrences\FixAllContext.DiagnosticProvider.cs (1)

86source: project.Solution.Projects,

CodeFixes\FixAllOccurrences\FixAllContextHelper.cs (1)

67var projectsToFix = project.Solution.Projects

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (1)

36_differenceService = document.Project.Solution.Services.GetRequiredService<IDocumentTextDifferencingService>();

CodeFixesAndRefactorings\CommonFixAllState.cs (1)

22public Solution Solution => Project.Solution;

CodeRefactorings\FixAllOccurences\FixAllContext.cs (1)

63public Solution Solution => Project.Solution;

CodeRefactorings\FixAllOccurences\FixAllState.cs (1)

116documentsToFix = Project.Solution.Projects.SelectMany(p => p.Documents);

CodeRefactorings\SyntaxEditorBasedCodeRefactoringProvider.cs (1)

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

Diagnostics\DiagnosticData.cs (3)

176var diagnosticSpanMappingService = document?.Project.Solution.Services.GetService<IWorkspaceVenusSpanMappingService>(); 266builder.AddIfNotNull(CreateLocation(document.Project.Solution.GetDocument(location.SourceTree), location)); 306diagnosticData = Create(project.Solution, diagnostic, project);

Editing\DocumentEditor.cs (1)

19: base(root, document.Project.Solution.Services)

Editing\SymbolEditor.cs (2)

51return new SymbolEditor(document.Project.Solution); 294ChangedSolution = newDoc.Project.Solution;

FindSymbols\Declarations\DeclarationFinder.cs (1)

83project.Solution, reference, checksum: null, cancellationToken).ConfigureAwait(false);

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (2)

40var solution = project.Solution; 99var referencedProject = project.Solution.GetProject(projectReference.ProjectId);

FindSymbols\Declarations\DeclarationFinder_SourceDeclarations.cs (4)

85project.Solution, 94return await RehydrateAsync(project.Solution, result.Value, cancellationToken).ConfigureAwait(false); 151project.Solution, 160return await RehydrateAsync(project.Solution, result.Value, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\DependentTypeFinder.cs (1)

345project.Solution, reference, checksum: null, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\DependentTypeFinder_ProjectIndex.cs (2)

56var solutionKey = SolutionKey.ToSolutionKey(project.Solution); 59var sourceGeneratorDocumentStates = await project.Solution.CompilationState.GetSourceGeneratedDocumentStatesAsync(project.State, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\FindReferencesDocumentState.cs (1)

29public Solution Solution => this.Document.Project.Solution;

FindSymbols\Shared\AbstractSyntaxIndex_Persistence.cs (1)

147SolutionKey.ToSolutionKey(document.Project.Solution),

FindSymbols\SymbolFinder.cs (1)

115return await FindSymbolAtPositionAsync(semanticModel, position, document.Project.Solution.Services, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolTree\SymbolTreeInfo_Source.cs (3)

36var solution = project.Solution; 56project.Solution.Services, 57SolutionKey.ToSolutionKey(project.Solution),

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (3)

83var solution = project.Solution; 194var checksum = SymbolTreeInfo.GetMetadataChecksum(project.Solution.Services, reference, cancellationToken); 199project.Solution, reference, checksum, cancellationToken).ConfigureAwait(false);

FindSymbols\SyntaxTree\SyntaxTreeIndex.cs (3)

39=> GetRequiredIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, cancellationToken); 45=> GetIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, cancellationToken); 51=> GetIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, loadOnly, cancellationToken);

FindSymbols\TopLevelSyntaxTree\TopLevelSyntaxTreeIndex.cs (3)

47=> GetRequiredIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, cancellationToken); 53=> GetIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, cancellationToken); 59=> GetIndexAsync(SolutionKey.ToSolutionKey(document.Project.Solution), document.Project.State, (DocumentState)document.State, loadOnly, cancellationToken);

Formatting\Formatter.cs (3)

95var services = document.Project.Solution.Services; 116var services = document.Project.Solution.Services; 133var services = document.Project.Solution.Services;

Recommendations\Recommender.cs (1)

60options ??= project.Solution.Options;

Remote\RemoteArguments.cs (1)

56: Dehydrate(document.Project.Solution, alias, cancellationToken);

Remote\RemoteHostClient.cs (1)

38return TryGetClientAsync(project.Solution.Services, cancellationToken);

Remote\RemoteServiceConnection.cs (4)

82=> TryInvokeAsync(project.Solution.CompilationState, project.Id, invocation, cancellationToken); 88=> TryInvokeAsync(project.Solution.CompilationState, project.Id, invocation, cancellationToken); 132=> TryInvokeAsync(project.Solution.CompilationState, project.Id, invocation, cancellationToken); 138=> TryInvokeAsync(project.Solution.CompilationState, project.Id, invocation, cancellationToken);

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

656var newReferencedSymbols = RenameUtilities.GetSymbolsTouchingPosition(tokenOrNode.Span.Start, newDocumentSemanticModel, newDocument.Project.Solution.Services, _cancellationToken);

Rename\ConflictEngine\RenamedSpansTracker.cs (1)

217solution = document.Project.Solution;

Rename\Renamer.cs (1)

76=> RenameDocumentAsync(document, GetDocumentRenameOptions(optionSet ?? document.Project.Solution.Options), newDocumentName, newDocumentFolders, cancellationToken);

Rename\Renamer.RenameSymbolDocumentAction.cs (1)

38var solution = document.Project.Solution;

Rename\Renamer.SyncNamespaceDocumentAction.cs (1)

48return solution ?? document.Project.Solution;

Rename\RenameUtilities.cs (1)

312var definitionSymbol = await FindDefinitionSymbolAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);

Shared\Extensions\DocumentExtensions.cs (1)

26=> document.Project.Solution.WithOptions(options).GetRequiredDocument(document.Id);

Shared\Extensions\ProjectExtensions.cs (3)

17=> project.Solution.WithOptions(options).GetProject(project.Id)!; 20=> project.Solution.GetTextDocument(documentId); 32=> project.Solution.GetDocumentIdsWithFilePath(filePath).FirstOrDefault(id => id.ProjectId == project.Id);

Shared\Extensions\SyntaxGeneratorExtensions.cs (1)

86&& await SymbolFinder.FindSourceDefinitionAsync(overriddenProperty, document.Project.Solution, cancellationToken).ConfigureAwait(false) is { Language: LanguageNames.VisualBasic })

Simplification\Simplifier.cs (3)

75return Expand(node, semanticModel, document.Project.Solution.Services, expandInsideNode, expandParameter, cancellationToken); 120return Expand(token, semanticModel, document.Project.Solution.Services, expandInsideNode, cancellationToken); 258var simplificationService = document.Project.Solution.Services.GetRequiredLanguageService<ISimplificationService>(document.Project.Language);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\DocumentExtensions.cs (3)

98var workspace = document.Project.Solution.Workspace; 163var semanticModelService = document.Project.Solution.Services.GetRequiredService<ISemanticModelReuseWorkspaceService>(); 219var solution = document.Project.Solution;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\ProjectExtensions.cs (2)

40=> project.Solution.Services.GetExtendedLanguageServices(project.Language); 91var solutionOrProjectFilePath = project.Solution?.FilePath ?? project.FilePath;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\TextDocumentExtensions.cs (2)

51return textDocument.Project.Solution.WithAdditionalDocumentText(textDocument.Id, text, PreservationMode.PreserveIdentity).GetTextDocument(textDocument.Id)!; 60return textDocument.Project.Solution.WithAnalyzerConfigDocumentText(textDocument.Id, text, PreservationMode.PreserveIdentity).GetTextDocument(textDocument.Id)!;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.State.cs (1)

91var findReferencesResult = await SymbolFinder.FindReferencesAsync(LocalSymbol, document.Project.Solution, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Workspace\Host\SupportedChangesServiceExtensions.cs (1)

13=> project.Solution.Services.GetRequiredService<ISupportedChangesService>().CanApplyParseOptionChange(oldOptions, newOptions, project);

Workspace\Host\PersistentStorage\ProjectKey.cs (1)

35=> ToProjectKey(project.Solution.SolutionState, project.State);

Workspace\Solution\Document.cs (11)

Workspace\Solution\Project.cs (49)

Workspace\Solution\SolutionCompilationState.cs (1)

1734if (!projectWithCachedGeneratorState.Solution.CompilationState.TryGetCompilationTracker(projectWithCachedGeneratorState.Id, out var tracker) ||

Workspace\Workspace.cs (2)

792oldSolution.RemoveProject(projectId).AddProject(reloadedProjectInfo).GetRequiredProject(projectId)).Solution; 1449solution = project.Solution;

Workspace\Workspace_Editor.cs (4)

872newSolution = document.WithText(this.GetOpenDocumentText(oldSolution, docId)).Project.Solution; 881var oldSolution = oldProject.Solution; 882var newSolution = reloadedProject.Solution; 890newSolution = document.WithText(this.GetOpenDocumentText(oldSolution, docId)).Project.Solution;

NetCoreTests.cs (2)

176Assert.Equal(projectRefFilePath, project.Solution.GetProject(projectRefId).FilePath); 520Assert.Equal(projectRefFilePath, project.Solution.GetProject(projectRefId).FilePath);

VisualStudioMSBuildWorkspaceTests.cs (13)

345var p2 = p1.Solution.Projects.First(p => p.Language == LanguageNames.VisualBasic); 1224Assert.Single(project.Solution.ProjectIds); // didn't really open referenced project due to invalid file path. 1253Assert.Single(project.Solution.ProjectIds); // didn't really open referenced project due to invalid file path. 1286Assert.Single(project.Solution.ProjectIds); // didn't really open referenced project due to unrecognized extension. 1324Assert.Single(project.Solution.ProjectIds); 1348Assert.Single(project.Solution.ProjectIds); 1371Assert.Single(project.Solution.ProjectIds); 2473Assert.NotNull(project.Solution.GetProjectsByName("CSharpProject").SingleOrDefault()); 2912var noEncodingSolution = noEncodingDoc.Project.Solution; 2941workspace.TryApplyChanges(project.AddAnalyzerReference(aref).Solution); 2946workspace.TryApplyChanges(workspace.CurrentSolution.GetProject(project.Id).RemoveAnalyzerReference(aref).Solution); 2967workspace.TryApplyChanges(workspace.CurrentSolution.GetProject(project.Id).RemoveProjectReference(pref).Solution); 2974workspace.TryApplyChanges(workspace.CurrentSolution.GetProject(project.Id).AddProjectReference(pref).Solution);

WorkspaceExtensions.cs (1)

19var newSolution = oldSolution.AddDocument(id, name, initialText, folders).GetDocument(id)!.WithSourceCodeKind(sourceCodeKind).Project.Solution;

FindReferencesTests.cs (5)

188var references = await SymbolFinder.FindReferencesAsync(symbol, prj.Solution); 193references = await SymbolFinder.FindReferencesAsync(symbol, prj.Solution); 224var references = await SymbolFinder.FindReferencesAsync(symbol, prj.Solution); 292var references = await SymbolFinder.FindReferencesAsync(symbol, prj.Solution); 297references = await SymbolFinder.FindReferencesAsync(symbol, prj.Solution);

Formatter\FormatterTests.cs (1)

78document = document.Project.Solution.WithOptions(solutionOptions).GetRequiredDocument(document.Id);

SolutionTests\SolutionTests.cs (42)

SolutionTests\SolutionWithSourceGeneratorTests.cs (31)

189var generatorDriver = project.Solution.CompilationState.GetTestAccessor().GetGeneratorDriver(project)!; 209generatorDriver = project.Solution.CompilationState.GetTestAccessor().GetGeneratorDriver(project)!; 233generatorDriver = project.Solution.CompilationState.GetTestAccessor().GetGeneratorDriver(project)!; 263project = project.Solution.WithDocumentText(documentId, SourceText.From("// Changed Source File")).Projects.Single(); 306project = project.Solution.WithAdditionalDocumentText(additionalDocumentId, SourceText.From("Hello, everyone!")).Projects.Single(); 311project = project.Solution.WithAdditionalDocumentText(additionalDocumentId, SourceText.From("Good evening, everyone!")).Projects.Single(); 373projectBeforeChange.Solution.WithAdditionalDocumentText( 410return project.Solution; 421.AddAdditionalDocument("Test.txt", "Hello, world!").Project.Solution; 592Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); 601Assert.NotSame(workspace.CurrentSolution, generatedDocument.Project.Solution); 616Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); 624Assert.Same(workspace.CurrentSolution, generatedDocument!.Project.Solution); 636Assert.True(workspace.SetCurrentSolution(_ => originalAdditionalFile.Project.Solution, WorkspaceChangeKind.SolutionChanged)); 661.AddAnalyzerReference(analyzerReference).Solution; 665new ProjectReference(projectIdWithGenerator)).Solution; 694Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); 723Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); 814var originalDocument2 = AddEmptyProject(originalDocument1.Project.Solution, name: "Project2") 818var frozenSolution = originalDocument2.WithFrozenPartialSemantics(CancellationToken.None).Project.Solution; 853project = project.Solution.AddDocument(documentInfo).Projects.Single() 887var frozenWithSingleDocument = project.Solution.WithFrozenSourceGeneratedDocument( 904var solution = AddEmptyProject(workspace.CurrentSolution).AddAnalyzerReference(analyzerReference).Solution; 907solution = project2.Solution; 934var frozenSolution = project.Solution.WithFrozenSourceGeneratedDocument( 936Assert.Same(project.Solution, frozenSolution.Project.Solution); 950var checksum0 = await project0.Solution.SolutionState.GetChecksumAsync(CancellationToken.None); 953var checksum1 = await project1.Solution.SolutionState.GetChecksumAsync(CancellationToken.None); 959var checksum2 = await project2.Solution.SolutionState.GetChecksumAsync(CancellationToken.None); 969var checksum3 = await project3.Solution.SolutionState.GetChecksumAsync(CancellationToken.None);

SolutionTests\TryApplyChangesTests.cs (4)

79Assert.True(workspace.TryApplyChanges(project.WithCompilationOptions(project.CompilationOptions!.WithMainTypeName("Test")).Solution)); 92Assert.True(workspace.TryApplyChanges(project.WithCompilationOptions(project.CompilationOptions!.WithMainTypeName("Test")).Solution)); 106() => workspace.TryApplyChanges(project.WithCompilationOptions(project.CompilationOptions!.WithMainTypeName("WrongThing")).Solution)); 166Assert.True(workspace.TryApplyChanges(project.AddAnalyzerConfigDocument(".editorconfig", SourceText.From("")).Project.Solution));

SymbolKeyTests.cs (2)

875workspace.TryApplyChanges(document.WithText(updated).Project.Solution); 922workspace.TryApplyChanges(document.WithText(updated).Project.Solution);

WorkspaceTests\AdhocWorkspaceTests.cs (3)

432Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 499Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 530Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution));

WorkspaceTests\WorkspaceTests.cs (4)

30Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 46Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 81Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message); 97Assert.Throws<NotSupportedException>(() => ws.TryApplyChanges(changedDoc.Project.Solution)).Message);