Id

CodeRefactoringRunner.cs (3)

66updatedSolution = updatedSolution.WithDocumentSyntaxRoot(document.Id, await newDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)); 112if (documentChanges.Length != 1 || documentChanges[0] != document.Id) 117return projectChanges[0].NewProject.GetDocument(document.Id);

AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

88.ToImmutableDictionary(group => solution.GetRequiredDocument(group.Key!).Id, group => group.ToImmutableArray());

AbstractMakeMethodAsynchronousCodeFixProvider.cs (1)

172var newDocument = newSolution.GetRequiredDocument(document.Id);

AbstractMakeMethodSynchronousCodeFixProvider.cs (2)

84var newDocument = newSolution.GetRequiredDocument(document.Id); 185return currentSolution.WithDocumentSyntaxRoot(document.Id, newRoot);

AddParameterService.cs (1)

141solution = solution.WithDocumentSyntaxRoot(document.Id, newRoot);

DocumentExtensions.cs (1)

80return workspace != null && workspace.IsDocumentOpen(document.Id);

ParsedDocument.cs (1)

38return new ParsedDocument(document.Id, text, root, document.Project.GetExtendedLanguageServices());

TextDocumentExtensions.cs (4)

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

ConvertToRecordEngine.cs (2)

120.GetDocumentEditorAsync(document.Id, cancellationToken).ConfigureAwait(false); 462var documentLookup = referenceLocations.ToLookup(refLoc => refLoc.Document.Id);

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (1)

184formattedDocument.Id, formattedDocument.GetTextSynchronously(cancellationToken));

CodeActions\ApplyChangesOperationTests.cs (10)

80return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content")); 85return solution.WithDocumentText(document2.Id, SourceText.From("NewProgram2Content")); 112return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content")); 117return solution.RemoveDocument(document2.Id); 144return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content1")); 149return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content2")); 175return solution.WithDocumentText(document1.Id, SourceText.From("NewProgram1Content1")); 180return solution.RemoveDocument(document1.Id); 207return solution.RemoveDocument(document1.Id); 212return solution.WithDocumentText(document2.Id, SourceText.From("NewProgram1Content2"));

CodeActions\Preview\PreviewExceptionTests.cs (1)

113textBuffer = workspace.GetTestDocument(document.Id).GetTextBuffer();

CodeActions\Preview\PreviewTests.cs (1)

88solution = solution.WithDocumentSyntaxRoot(_oldDocument.Id, CSharpSyntaxTree.ParseText(ChangedDocumentText, cancellationToken: cancellationToken).GetRoot(cancellationToken));

EditAndContinue\ActiveStatementTrackingServiceTests.cs (2)

208var spans2 = await trackingSession.GetSpansAsync(solution, document1.Id, document1.FilePath, CancellationToken.None); 211var spans3 = await trackingSession.GetSpansAsync(solution, document2.Id, document2.FilePath, CancellationToken.None);

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (9)

307var documentId = oldDocument.Id; 372var documentId = oldDocument.Id; 433var documentId = oldDocument.Id; 469var documentId = oldDocument.Id; 515var documentId = oldDocument.Id; 547var documentId = oldDocument.Id; 584var documentId = oldDocument.Id; 623var documentId = oldDocument.Id; 799var documentId = oldProject.Documents.Single().Id;

EditorConfigSettings\Updater\SettingsUpdaterTests.cs (1)

367var newSolution = solution.WithAnalyzerConfigDocumentText(editorconfig.Id, text);

Formatting\CodeCleanupTests.TestFixers.cs (2)

112solution = solution.WithDocumentText(document.Id, await document.GetTextAsync()); 168solution = solution.WithDocumentText(document.Id, await document.GetTextAsync());

TaskList\NoCompilationTaskListTests.cs (1)

66document.Id,

Workspaces\WorkspaceTests_EditorFeatures.cs (10)

CodeRefactorings\EnableNullable\EnableNullableCodeRefactoringProvider.cs (1)

76solution = solution.WithDocumentSyntaxRoot(document.Id, updatedDocumentRoot);

Completion\CompletionProviders\ImportCompletion\ImportCompletionProviderHelper.cs (1)

73_sdkGlobalUsingsCache[project.Id] = new(globalUsingDocument.Id, checksum, globalUsings);

ConvertToRecordEngine.cs (2)

120.GetDocumentEditorAsync(document.Id, cancellationToken).ConfigureAwait(false); 462var documentLookup = referenceLocations.ToLookup(refLoc => refLoc.Document.Id);

GenerateType\CSharpGenerateTypeService.cs (1)

805updatedSolution = updatedSolution.WithDocumentSyntaxRoot(document.Id, addedCompilationRoot, PreservationMode.PreserveIdentity);

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

242document.Id, cancellationToken).ConfigureAwait(false);

ImplementInterface\CSharpImplementExplicitlyCodeRefactoringProvider.cs (1)

75document.Id, cancellationToken).ConfigureAwait(false);

Rename\CSharpRenameRewriterLanguageService.cs (1)

127_documentId = parameters.Document.Id;

CodeActions\CodeActionEditHandlerService.cs (1)

173transaction.AddDocument(fromDocument.Id);

CodeDefinitionWindow\DefinitionContextTracker.cs (1)

172if (await navigationService.CanNavigateToSpanAsync(workspace, item.Document.Id, item.SourceSpan, cancellationToken).ConfigureAwait(false))

Diagnostics\AbstractPushOrPullDiagnosticsTaggerProvider.PushDiagnosticsTaggerProvider.cs (2)

140workspace, document.Project.Id, document.Id, cancellationToken); 164workspace, document.Project.Id, document.Id, id,

EditAndContinue\ActiveStatementTrackingService.cs (1)

170var compileTimeDocument = await compileTimeSolution.GetDocumentAsync(designTimeDocument.Id, includeSourceGenerated: true, cancellationToken).ConfigureAwait(false);

Extensibility\NavigationBar\AbstractEditorNavigationBarItemService.cs (1)

82return Task.FromResult((document.Id, navigationSpan.Start, 0));

ExternalAccess\VSTypeScript\VSTypeScriptNavigationBarItemService.cs (1)

68_threadingContext, workspace, document.Id, navigationSpan.Start, virtualSpace: 0, NavigationOptions.Default, cancellationToken).ConfigureAwait(false);

Formatting\FormatCommandHandler.cs (1)

81changes = ruleFactory.FilterFormattedChanges(document.Id, selectionOpt.Value, changes).ToImmutableArray();

Formatting\FormatCommandHandler.Paste.cs (1)

73if (formattingRuleService != null && formattingRuleService.ShouldNotFormatOrCommitOnPaste(document.Id))

GoToDefinition\AbstractGoToDefinitionService.cs (1)

43workspace, document.Id, position, virtualSpace: 0, cancellationToken);

InlineRename\InlineRenameService.cs (1)

157workspace, document.Id, documentSpan.SourceSpan, cancellationToken).ConfigureAwait(false);

InlineRename\InlineRenameSession.cs (3)

424var locationsByDocument = locations.ToLookup(l => l.Document.Id); 431if (!documents.Any(static (d, locationsByDocument) => locationsByDocument.Contains(d.Id), locationsByDocument)) 437var spans = documents.SelectMany(d => locationsByDocument[d.Id]).Select(l => l.TextSpan).Distinct();

InlineRename\InlineRenameSession.OpenTextBufferManager.cs (13)

331var newDocument = mergeResult.MergedSolution.GetDocument(documents.First().Id); 332var originalDocument = _baseDocuments.Single(d => d.Id == newDocument.Id); 357.Select(document => (document, conflictResolution.GetReplacements(document.Id).Where(r => GetRenameSpanKind(r.Kind) != RenameSpanKind.None).ToImmutableArray())) 410var firstDocumentNewText = conflictResolution.NewSolution.GetDocument(firstDocumentReplacements.document.Id).GetTextAsync(cancellationToken).WaitAndGetResult(cancellationToken); 419var documentNewText = conflictResolution.NewSolution.GetDocument(document.Id).GetTextAsync(cancellationToken).WaitAndGetResult(cancellationToken); 440var relevantReplacements = conflictResolution.GetReplacements(document.Id).Where(r => GetRenameSpanKind(r.Kind) != RenameSpanKind.None); 449conflictResolution.NewSolution.GetDocument(document.Id), 450mergeResult.MergedSolution.GetDocument(document.Id), 456var mergeConflictComments = mergeResult.MergeConflictCommentSpans.ContainsKey(document.Id) 457? mergeResult.MergeConflictCommentSpans[document.Id] 552if (newDocument.Id != oldDocument.Id)

IntelliSense\Helpers.cs (1)

158var documentId = document.Id;

NavigateTo\NavigateToHelpers.cs (1)

52document.Id,

NavigationBar\NavigationBarController.cs (1)

225documentId: d.Id,

Preview\AbstractPreviewFactoryService.cs (6)

291rightWorkspace.OpenDocument(document.Id, newBuffer.AsTextContainer()); 373leftWorkspace.OpenDocument(document.Id, oldBuffer.AsTextContainer()); 481leftWorkspace.OpenDocument(oldDocument.Id, oldBuffer.AsTextContainer()); 484rightWorkspace.OpenDocument(newDocument.Id, newBuffer.AsTextContainer()); 538leftWorkspace.OpenDocument(oldDocument.Id, oldBuffer.AsTextContainer()); 541rightWorkspace.OpenDocument(newDocument.Id, newBuffer.AsTextContainer());

Remote\SolutionChecksumUpdater.cs (1)

223(service, cancellationToken) => service.SynchronizeTextAsync(oldDocument.Id, state.Text, textChanges, cancellationToken),

RenameTracking\RenameTrackingCancellationCommandHandler.cs (1)

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

RenameTracking\RenameTrackingTaggerProvider.RenameTrackingCommitter.cs (2)

87var symbol = await TryGetSymbolAsync(solutionWithOriginalName, document.Id, cancellationToken).ConfigureAwait(false); 197foreach (var documentId in document.GetLinkedDocumentIds().Add(document.Id))

RenameTracking\RenameTrackingTaggerProvider.StateMachine.cs (1)

245documentIds: SpecializedCollections.SingletonEnumerable(document.Id), highPriority: true);

Shared\Extensions\WorkspaceExtensions.cs (2)

23var oldDocument = oldSolution.GetRequiredDocument(newDocument.Id); 25var newSolution = oldSolution.UpdateDocument(newDocument.Id, changes, cancellationToken);

Shared\Tagging\EventSources\TaggerEventSources.DocumentActiveContextChangedEventSource.cs (1)

30if (document != null && document.Id == e.NewActiveContextDocumentId)

ChangeSignature\AbstractChangeSignatureTests.cs (1)

129var updatedInvocationDocument = result.UpdatedSolution.GetDocument(testState.InvocationDocument.Id);

Diagnostics\AbstractUserDiagnosticTest_GenerateTypeDialog.cs (3)

118expectedChangedDocumentId: testState.ExistingDocument.Id); 140expectedChangedDocumentId: testState.InvocationDocument.Id); 149Assert.False(changedDocumentIds.Contains(testState.InvocationDocument.Id));

Diagnostics\TestDiagnosticAnalyzerDriver.cs (1)

62var dxs = await _diagnosticAnalyzerService.GetDiagnosticsAsync(project.Solution, project.Id, document.Id, _includeSuppressedDiagnostics);

EditAndContinue\EditAndContinueTestHelpers.cs (1)

409newSolution = newSolution.WithDocumentSyntaxRoot(oldDocument.Id, editScripts[documentIndex].Match.NewRoot, PreservationMode.PreserveIdentity);

ExtractInterface\AbstractExtractInterfaceTests.cs (2)

135var updatedOriginalDocument = result.UpdatedSolution.GetDocument(testState.ExtractFromDocument.Id); 162var updatedDocument = updatedSolution.GetDocument(testState.ExtractFromDocument.Id);

SignatureHelp\AbstractSignatureHelpProviderTests.cs (2)

101document1 = document1.Project.WithParseOptions(parseOptions).GetDocument(document1.Id); 112document2 = document2.Project.WithParseOptions(parseOptions).GetDocument(document2.Id);

Workspaces\TestHostDocument.cs (1)

67_id = sourceGeneratedDocuments.Single(d => d.FilePath == this.FilePath).Id;

CodeFixes\CodeFixServiceTests.cs (3)

825var changedtxtDocument = solution!.Projects.Single().AdditionalDocuments.Single(t => t.Id == txtDocument.Id); 882return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText);

CodeRefactorings\CodeRefactoringServiceTest.cs (6)

190var changedtxtDocument = solution.Projects.Single().AdditionalDocuments.Single(t => t.Id == txtAdditionalDocument.Id); 229var changedEditorConfig = solution.Projects.Single().AnalyzerConfigDocuments.Single(t => t.Id == editorConfig.Id); 257return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); 258return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (18)

Diagnostics\DiagnosticDataTests.cs (8)

128location: new DiagnosticDataLocation(new("originalFile1", new(startLine, startColumn), new(endLine, endColumn)), document.Id), 148new(additionalDocument.Name, new(0, 0), new(0, 1)), additionalDocument.Id); 161location: new DiagnosticDataLocation(new FileLinePositionSpan(document.FilePath, span: default), document.Id), 239firstDocument = secondDocument.Project.Solution.GetRequiredDocument(firstDocument.Id); 242new(secondDocument.Name, new(0, 0), new(0, 1)), secondDocument.Id); 255location: new DiagnosticDataLocation(new FileLinePositionSpan(firstDocument.FilePath, span: default), firstDocument.Id), 264.RemoveDocument(secondDocument.Id) 265.GetRequiredDocument(firstDocument.Id);

Diagnostics\DiagnosticServiceTests.cs (11)

Diagnostics\MockDiagnosticService.cs (1)

75=> workspace.CurrentSolution.Projects.Single().Documents.Single().Id;

EditAndContinue\CompileTimeSolutionProviderTests.cs (1)

76compileTimeSolution, ImmutableArray.Create(documentId, sourceGeneratedDoc.Id), designTimeSolution, CancellationToken.None, sourceGeneratedPathPrefix);

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (102)

EditAndContinue\EmitSolutionUpdateResultsTests.cs (5)

50DiagnosticDataLocation.TestAccessor.Create(new("a.cs", new(0, 0), new(0, 5)), document.Id, new("a.razor", new(10, 10), new(10, 15)), forceMappedPath: true), 66DiagnosticDataLocation.TestAccessor.Create(new(sourcePath, new(0, 0), new(0, 5)), document.Id, new(@"..\a.razor", new(10, 10), new(10, 15)), forceMappedPath: true), 83new DiagnosticDataLocation(new(sourcePath, new(0, 1), new(0, 5)), document.Id), 90(document.Id, ImmutableArray.Create(new RudeEditDiagnostic(RudeEditKind.Insert, TextSpan.FromBounds(1, 10), 123, new[] { "a" }))), 91(document.Id, ImmutableArray.Create(new RudeEditDiagnostic(RudeEditKind.Delete, TextSpan.FromBounds(1, 10), 123, new[] { "b" }))));

LinkedFiles\LinkedFileDiffMergingEditorTests.cs (2)

86.WithDocumentText(document.Id, (await document.GetTextAsync()).Replace(13, 1, "D")) 87.WithDocumentText(linkedDocument.Id, (await linkedDocument.GetTextAsync()).Replace(0, 6, "private"));

MetadataAsSource\AbstractMetadataAsSourceTests.cs (1)

89metadataProject = metadataProject.RemoveDocument(newDoc.Id);

Preview\PreviewWorkspaceTests.cs (4)

114previewWorkspace.OpenDocument(document.Id, sourceTextContainer); 116Assert.True(previewWorkspace.IsDocumentOpen(document.Id)); 118previewWorkspace.CloseDocument(document.Id); 120Assert.False(previewWorkspace.IsDocumentOpen(document.Id));

SolutionCrawler\WorkCoordinatorTests.cs (17)

604var worker = await ExecuteOperation(workspace, w => w.OnDocumentRemoved(document.Id)); 706var worker = await ExecuteOperation(workspace, w => w.ChangeDocument(document.Id, SourceText.From("//"))); 833workspace.ChangeDocument(document.Id, SourceText.From("//")); 841workspace.ChangeDocument(document.Id, SourceText.From("// ")); 888workspace.ChangeDocument(document.Id, SourceText.From("//")); 895workspace.ChangeDocument(document.Id, SourceText.From("// ")); 903workspace.ChangeDocument(document.Id, SourceText.From("// ")); 1674documentTrackingService.SetActiveDocument(document.Id); 1876this.DocumentIds.Add(document.Id); 1884this.SyntaxDocumentIds.Add(document.Id); 1885Process(document.Id, cancellationToken); 1891this.NonSourceDocumentIds.Add(textDocument.Id); 1927OpenedDocumentIds.Add(document.Id); 1933ClosedDocumentIds.Add(document.Id); 1939OpenedNonSourceDocumentIds.Add(textDocument.Id); 1945ClosedNonSourceDocumentIds.Add(textDocument.Id); 1993this.DocumentIds.Add(document.Id);

Peek\PeekableItemSource.cs (1)

137workspace, document.Id, item.SourceSpan.Start, cancellationToken).ConfigureAwait(false))

QuickInfo\ContentControlService.cs (1)

72workspace.OpenDocument(document.Id, textBuffer.AsTextContainer());

Diagnostics\AdditionalFileDiagnosticsTests.vb (1)

122Dim newSln = appConfigDoc.Project.Solution.WithAdditionalDocumentText(appConfigDoc.Id, SourceText.From("true", text.Encoding))

FindReferences\FindReferencesTests.vb (3)

557solution = solution.WithDocumentText(document2.Id, SourceText.From("")) 561solution = solution.WithDocumentText(document2.Id, text1) 566solution = solution.WithDocumentText(document2.Id, SourceText.From(text1.ToString().Replace("int i", "int j")))

Internal\Editor\FSharpNavigationBarItemService.cs (2)

74if (navigationService.CanNavigateToPosition(workspace, document.Id, span.Start, virtualSpace: 0, cancellationToken)) 76navigationService.TryNavigateToPosition(workspace, document.Id, span.Start, virtualSpace: 0, cancellationToken);

Internal\Editor\FSharpSmartIndentProvider.cs (1)

95result = _provider._service.GetDesiredIndentation(document.Project.LanguageServices, text, document.Id, document.FilePath, line.LineNumber, fsharpOptions);

TaskList\FSharpTaskListService.cs (1)

49return new TaskListItem(priority, d.Message, document.Id, span, span);

AbstractChangeNamespaceToMatchFolderCodeFixProvider.CustomFixAllProvider.cs (1)

88.ToImmutableDictionary(group => solution.GetRequiredDocument(group.Key!).Id, group => group.ToImmutableArray());

AbstractMakeMethodAsynchronousCodeFixProvider.cs (1)

172var newDocument = newSolution.GetRequiredDocument(document.Id);

AbstractMakeMethodSynchronousCodeFixProvider.cs (2)

84var newDocument = newSolution.GetRequiredDocument(document.Id); 185return currentSolution.WithDocumentSyntaxRoot(document.Id, newRoot);

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (1)

186var intent = new IntentProcessorResult(changedSolution, ImmutableArray.Create(priorDocument.Id), action.Title, action.ActionName);

AddImport\AbstractAddImportFeatureService.cs (2)

68service.GetFixesAsync(solutionInfo, callbackId, document.Id, span, diagnosticId, maxResults, options, packageSources, cancellationToken), 519service.GetUniqueFixesAsync(solutionInfo, callbackId, document.Id, span, diagnosticIds, options, packageSources, cancellationToken),

AddImport\CodeActions\InstallPackageAndAddImportCodeAction.cs (1)

95OriginalDocument.Id, oldText, newText, _installOperation));

AddPackage\InstallPackageDirectlyCodeActionOperation.cs (1)

76workspace, _document.Id, _source, _packageName,

AddParameterService.cs (1)

141solution = solution.WithDocumentSyntaxRoot(document.Id, newRoot);

CodeFixes\Configuration\ConfigurationUpdater.cs (1)

291return solution.WithAnalyzerConfigDocumentText(editorConfigDocument.Id, newText);

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (5)

347documentIdToFinalText.TryAdd(document.Id, finalText); 356var oldDocument = oldSolution.GetRequiredDocument(orderedDocuments[0].document.Id); 362Debug.Assert(currentDocument.Id == oldDocument.Id); 369documentIdToFinalText.TryAdd(oldDocument.Id, newText);

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

36new OpenDocumentOperation(changedSuppressionDocument.Id, activateIfAlreadyOpen: true), 37new DocumentNavigationOperation(changedSuppressionDocument.Id, position: 0)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.RemoveSuppressionCodeAction.BatchFixer.cs (1)

145currentSolution = currentSolution.WithDocumentSyntaxRoot(document.Id, newRoot);

CodeLens\CodeLensReferencesService.cs (1)

149var documentId = solution.GetDocument(location.SourceTree)?.Id;

CodeRefactorings\AddMissingImports\AbstractAddMissingImportsFeatureService.cs (2)

138var newDocument = newProject.GetRequiredDocument(document.Id).WithText(newText); 231var newDocument = newSolution.GetRequiredDocument(document.Id);

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

70var sourceDocument = solutionWithNewDocument.GetRequiredDocument(SemanticDocument.Document.Id); 76return await RemoveUnnecessaryImportsAsync(solutionWithBothDocumentsUpdated, sourceDocument.Id, documentWithMovedType.Id).ConfigureAwait(false);

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

29.WithDocumentName(SemanticDocument.Document.Id, FileName); 39var documentId = SemanticDocument.Document.Id;

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (9)

157document = solution.GetRequiredDocument(document.Id); 302containers.Add((document.Id, container)); 362allDocumentIds = linkedDocumentIds.Add(document.Id); 456if (refLocation.Document.Id == document.Id) 473var refLocationGroups = refLocationsInOtherDocuments.GroupBy(loc => loc.Document.Id); 494document.Id, 707Debug.Assert(document.Id == refLoc.Document.Id);

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

48solution = solution.RemoveDocument(document.Id);

Completion\Providers\AbstractPreprocessorCompletionProvider.cs (1)

33foreach (var documentId in solution.GetRelatedDocumentIds(originatingDocument.Id))

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

Completion\Providers\AbstractSymbolCompletionProvider.cs (2)

274var contextAndSymbolLists = await GetPerContextSymbolsAsync(completionContext, document, options, new[] { document.Id }.Concat(relatedDocumentIds), cancellationToken).ConfigureAwait(false); 327return (relatedDocument.Id, syntaxContext, symbols);

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

73solutionInfo, document.Id, position, receiverTypeSymbolKeyData, namespaceInScope.ToImmutableArray(),

Completion\Providers\SymbolCompletionItem.cs (1)

203if (supportedPlatforms != null && supportedPlatforms.InvalidProjects.Contains(document.Id.ProjectId))

Completion\SharedSyntaxContextsWithSpeculativeModel.cs (3)

35if (_document.Id != document.Id && !_lazyRelatedDocumentIds.Value.Contains(document.Id))

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (2)

220(service, solutionInfo, callbackId, cancellationToken) => service.ConvertToStructAsync(solutionInfo, callbackId, document.Id, span, scope, isRecord, cancellationToken), 582var docId = currentDoc.Id;

DesignerAttribute\DesignerAttributeDiscoveryService.cs (3)

127specificDocument = specificDocument is null ? null : project.GetRequiredDocument(specificDocument.Id); 197if (_documentToLastReportedInformation.TryGetValue(document.Id, out var existingInfo) && 223DocumentId = document.Id,

DocumentHighlighting\AbstractDocumentHighlightsService.cs (2)

48(service, solutionInfo, cancellationToken) => service.GetDocumentHighlightsAsync(solutionInfo, document.Id, position, documentsToSearch.SelectAsArray(d => d.Id), options, cancellationToken),

DocumentHighlighting\IRemoteDocumentHighlightsService.cs (1)

38=> new(highlights.Document.Id, highlights.HighlightSpans);

DocumentIdSpan.cs (1)

32=> new(documentSpan.Document.Id, documentSpan.SourceSpan);

DocumentSpanExtensions.cs (1)

25return service.GetLocationForSpanAsync(workspace, documentSpan.Document.Id, documentSpan.SourceSpan, allowInvalidSpan: false, cancellationToken);

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (7)

529var oldDocument = await oldProject.GetDocumentAsync(newDocument.Id, includeSourceGenerated: true, cancellationToken).ConfigureAwait(false); 565return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, ImmutableArray<RudeEditDiagnostic>.Empty, syntaxError, hasChanges); 576return DocumentAnalysisResults.Unchanged(newDocument.Id, filePath); 585return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, ImmutableArray.Create( 595return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, ImmutableArray.Create( 674newDocument.Id, 697return DocumentAnalysisResults.SyntaxErrors(newDocument.Id, filePath, ImmutableArray.Create(diagnostic), syntaxError: null, hasChanges);

EditAndContinue\CommittedSolution.cs (1)

143Contract.ThrowIfFalse(currentDocument == null || documentId == currentDocument.Id);

EditAndContinue\DebuggingSession.cs (8)

482var (oldDocument, oldDocumentState) = await LastCommittedSolution.GetDocumentAndStateAsync(document.Id, document, cancellationToken).ConfigureAwait(false); 512EditSession.TrackDocumentWithReportedDiagnostics(document.Id); 690var (oldDocument, _) = await LastCommittedSolution.GetDocumentAndStateAsync(newDocument.Id, newDocument, cancellationToken).ConfigureAwait(false); 801var newDocumentActiveStatementSpans = await activeStatementSpanProvider(mappedDocument.Id, mappedDocument.FilePath, cancellationToken).ConfigureAwait(false); 819var (oldUnmappedDocument, _) = await LastCommittedSolution.GetDocumentAndStateAsync(newUnmappedDocument.Id, newUnmappedDocument, cancellationToken).ConfigureAwait(false); 884var (oldDocument, _) = await LastCommittedSolution.GetDocumentAndStateAsync(newDocument.Id, newDocument, cancellationToken).ConfigureAwait(false); 953var (oldDocument, _) = await LastCommittedSolution.GetDocumentAndStateAsync(newDocument.Id, newDocument, cancellationToken).ConfigureAwait(false); 1068var (oldDocument, _) = await oldSolution.GetDocumentAndStateAsync(newDocument.Id, newDocument, cancellationToken).ConfigureAwait(false);

EditAndContinue\EditAndContinueDocumentAnalysesCache.cs (5)

126var newMappedDocumentSpans = await newActiveStatementSpanProvider(newDocument.Id, newDocument.FilePath, cancellationToken).ConfigureAwait(false); 146newMappedDocumentSpans = await newActiveStatementSpanProvider((newDocument.FilePath == mappedFilePath) ? newDocument.Id : null, mappedFilePath, cancellationToken).ConfigureAwait(false); 158Debug.Assert(newMappedDocumentActiveSpan.UnmappedDocumentId == null || newMappedDocumentActiveSpan.UnmappedDocumentId == newDocument.Id); 183if (_analyses.TryGetValue(document.Id, out var analysis) && 210_analyses[document.Id] = (lazyResults, baseProject, document, activeStatementSpans);

EditAndContinue\EditSession.cs (1)

515var (oldDocument, oldDocumentState) = await DebuggingSession.LastCommittedSolution.GetDocumentAndStateAsync(newDocument.Id, newDocument, cancellationToken, reloadOutOfSyncDocument: true).ConfigureAwait(false);

EditAndContinue\Remote\RemoteDebuggingSessionProxy.cs (1)

275(service, solutionInfo, callbackId, cancellationToken) => service.GetAdjustedActiveStatementSpansAsync(solutionInfo, callbackId, _sessionId, document.Id, cancellationToken),

EditAndContinue\Remote\RemoteEditAndContinueServiceProxy.cs (1)

196(service, solutionInfo, callbackId, cancellationToken) => service.GetDocumentDiagnosticsAsync(solutionInfo, callbackId, document.Id, cancellationToken),

EncapsulateField\AbstractEncapsulateFieldService.cs (7)

120(service, solutionInfo, callbackId, cancellationToken) => service.EncapsulateFieldsAsync(solutionInfo, callbackId, document.Id, fieldSymbolKeys, updateReferences, cancellationToken), 146document = currentSolution.GetDocument(document.Id); 196document = solution.GetDocument(document.Id); 210document = solutionNeedingProperty.GetDocument(document.Id); 229document = solution.GetDocument(document.Id); 278document = solution.GetDocument(document.Id); 340=> GetConstructorNodes(containingType).Select(n => (solution.GetRequiredDocument(n.SyntaxTree).Id, n.Span)).ToSet();

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

421var oldProjectSourceGeneratedDocumentsById = oldProjectSourceGeneratedDocuments.ToDictionary(static document => document.Id); 423var newProjectSourceGeneratedDocumentsById = newProjectSourceGeneratedDocuments.ToDictionary(static document => document.Id); 508await EnqueueDocumentWorkItemAsync(project, document.Id, document, invocationReasons).ConfigureAwait(false); 606await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, UnitTestingInvocationReasons.DocumentChanged).ConfigureAwait(false); 617await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 644list.Add(new UnitTestingWorkItem(document.Id, document.Project.Language, UnitTestingInvocationReasons.DocumentAdded, isLowPriority: false, activeMember: null, EmptyAsyncToken.Instance));

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

177var projectId = thisDocument.Id.ProjectId; 184if (documentId == null || thisDocument.Id == documentId)

ExternalAccess\VSTypeScript\VSTypeScriptTaskListService.cs (1)

49return new TaskListItem(d.Descriptor.Descriptor.Priority, d.Message, document.Id, span, span);

ExtractClass\ExtractClassWithDialogCodeAction.cs (3)

109symbolMapping.AnnotatedSolution.GetRequiredDocument(_document.Id), 135var documentWithTypeDeclaration = solutionWithUpdatedOriginalType.GetRequiredDocument(updatedDocument.Id); 219var updatedOriginalDocument = solution.GetRequiredDocument(_document.Id);

ExtractInterface\AbstractExtractInterfaceService.cs (5)

212symbolMapping.DocumentIdsToSymbolMap.Keys.Concat(unformattedInterfaceDocument.Id), 219navigationDocumentId: unformattedInterfaceDocument.Id); 233var document = symbolMapping.AnnotatedSolution.GetDocument(refactoringResult.DocumentToExtractFrom.Id); 253symbolMapping.DocumentIdsToSymbolMap.Keys.Concat(refactoringResult.DocumentToExtractFrom.Id), 260navigationDocumentId: refactoringResult.DocumentToExtractFrom.Id);

FindUsages\IRemoteFindUsagesService.cs (1)

176=> new(documentSpan.Document.Id, documentSpan.SourceSpan);

FullyQualify\AbstractFullyQualifyService.cs (1)

48(service, solutionChecksum, cancellationToken) => service.GetFixDataAsync(solutionChecksum, document.Id, span, hideAdvancedMembers, cancellationToken),

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.cs (1)

120return new IntentProcessorResult(applyChangesOperation.ChangedSolution, ImmutableArray.Create(priorDocument.Id), codeAction.Title, type.Name);

GenerateConstructorFromMembers\AbstractGenerateConstructorFromMembersCodeRefactoringProvider.GenerateConstructorWithDialogCodeAction.cs (1)

113constructorDocument.Id, constructorSyntax.SpanStart));

GenerateType\AbstractGenerateTypeService.Editor.cs (3)

454var updatedSolution = solution.WithDocumentSyntaxRoot(generateTypeOptionsResult.ExistingDocument.Id, newRoot, PreservationMode.PreserveIdentity); 461generateTypeOptionsResult.ExistingDocument.Id == _semanticDocument.Document.Id ? newRoot : null,

InheritanceMargin\AbstractInheritanceMarginService.cs (1)

60service.GetInheritanceMarginItemsAsync(solutionInfo, document.Id, spanToSearch, includeGlobalImports: includeGlobalImports, frozenPartialSemantics: frozenPartialSemantics, cancellationToken),

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (3)

406var currentDocument = currentSolution.GetRequiredDocument(document.Id); 524otherDocument.Id, otherRoot.ReplaceNode(propertySyntax, withoutThrowNotImplemented)); 529return currentSolution.WithDocumentSyntaxRoot(document.Id, editor.GetChangedRoot());

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

359var callerDocumentEditor = await solutionEditor.GetDocumentEditorAsync(document.Id, cancellationToken).ConfigureAwait(false);

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (1)

245modifiedSolution = modifiedSolution.WithDocumentSyntaxRoot(document.Id, newRoot);

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (4)

269if (currentDocument.Id == _originalDocument.Id) 535if (document.Id == _originalDocument.Id)

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

323if (!_openedDocumentIds.TryGetKey(document.Id, out fileInfo))

MoveStaticMembers\MoveStaticMembersWithDialogCodeAction.cs (4)

88sourceDoc.Id, 131sourceDoc = solutionWithFixedReferences.GetRequiredDocument(sourceDoc.Id); 202newTypeDoc = solutionWithFixedReferences.GetRequiredDocument(newTypeDoc.Id); 225var documentToLocations = referencesForProject.ToLookup(reference => reference.location.Document.Id);

MoveToNamespace\AbstractMoveToNamespaceService.cs (3)

236return new MoveToNamespaceResult(originalSolution, changedSolution, document.Id, newNameOriginalSymbolMapping); 262var modifiedDocument = modifiedSolution.GetDocument(document.Id); 268var mergedDocument = mergedSolution.GetDocument(document.Id);

NavigateTo\AbstractNavigateToSearchService.InProcess.cs (2)

54var highPriDocs = priorityDocuments.Where(d => project.ContainsDocument(d.Id)).ToSet(); 97document.Id, document, patternName, patternContainer, kinds, onResultFound, index, cancellationToken).ConfigureAwait(false);

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (2)

40service.SearchDocumentAsync(solutionInfo, document.Id, searchPattern, kinds.ToImmutableArray(), callbackId, cancellationToken), 71var priorityDocumentIds = priorityDocuments.SelectAsArray(d => d.Id);

NavigationBar\AbstractNavigationBarItemService.cs (1)

28var documentId = document.Id;

QuickInfo\CommonSemanticQuickInfoProvider.cs (1)

92(document.Id, mainTokenInformation)

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (4)

230updatedSolution = updatedSolution.WithDocumentSyntaxRoot(originalDocument.Id, editor.GetChangedRoot()); 393if (setMethodDocument?.Id == documentId) 422if (getMethodDeclaration != null && updatedSolution.GetDocument(getMethodDeclaration.SyntaxTree)?.Id == documentId) 469result.Add(document.Id, definition);

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (3)

235updatedSolution = updatedSolution.WithDocumentSyntaxRoot(originalDocument.Id, editor.GetChangedRoot()); 334result.Add(document.Id, definition); 411if (property != null && declaration != null && updatedSolution.GetDocument(declaration.SyntaxTree)?.Id == documentId)

Shared\Utilities\AnnotatedSymbolMapping.cs (2)

73documentIdToSymbolsMap.Add(solution.GetRequiredDocument(typeNode.SyntaxTree).Id, new List<ISymbol>()); 79var id = solution.GetRequiredDocument(tree).Id;

SolutionCrawler\WorkCoordinator.cs (8)

267() => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentOpened), _shutdownToken); 273() => EnqueueDocumentWorkItemAsync(e.Document.Project, e.Document.Id, e.Document, InvocationReasons.DocumentClosed), _shutdownToken); 368var oldProjectSourceGeneratedDocumentsById = oldProjectSourceGeneratedDocuments.ToDictionary(static document => document.Id); 370var newProjectSourceGeneratedDocumentsById = newProjectSourceGeneratedDocuments.ToDictionary(static document => document.Id); 455await EnqueueDocumentWorkItemAsync(project, document.Id, document, invocationReasons).ConfigureAwait(false); 543await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, InvocationReasons.DocumentChanged).ConfigureAwait(false); 550await EnqueueDocumentWorkItemAsync(newDocument.Project, newDocument.Id, newDocument, differenceResult.ChangeType, differenceResult.ChangedMember).ConfigureAwait(false); 577list.Add(new WorkItem(document.Id, document.Project.Language, InvocationReasons.DocumentAdded, isLowPriority: false, activeMember: null, EmptyAsyncToken.Instance));

SolutionCrawler\WorkCoordinator.NormalPriorityProcessor.cs (2)

354SolutionCrawlerLogger.LogProcessOpenDocument(Processor._logAggregator, textDocument.Id.Id); 379SolutionCrawlerLogger.LogProcessCloseDocument(Processor._logAggregator, textDocument.Id.Id);

SolutionCrawler\WorkCoordinator.SemanticChangeProcessor.cs (2)

176var projectId = thisDocument.Id.ProjectId; 183if (documentId == null || thisDocument.Id == documentId)

TaskList\AbstractTaskListService.cs (2)

38(service, checksum, cancellationToken) => service.GetTaskListItemsAsync(checksum, document.Id, descriptors, cancellationToken), 117commentDescriptor.Priority, trimmedMessage, document.Document.Id, location.GetLineSpan(), location.GetMappedLineSpan()));

UseAutoProperty\AbstractUseAutoPropertyCodeFixProvider.cs (7)

136fieldDocument.Id == documentId ? !span.IntersectsWith(declaratorLocation.SourceSpan) : true && // The span check only makes sense if we are in the same file 148fieldDocument = solution.GetRequiredDocument(fieldDocument.Id); 149propertyDocument = solution.GetRequiredDocument(propertyDocument.Id); 216return solution.WithDocumentSyntaxRoot(fieldDocument.Id, newRoot); 231var updatedSolution = solution.WithDocumentSyntaxRoot(fieldDocument.Id, newFieldTreeRoot); 232updatedSolution = updatedSolution.WithDocumentSyntaxRoot(propertyDocument.Id, newPropertyTreeRoot); 273canEdit[documentId] = document != null && !linkedDocuments.Contains(document.Id);

ValueTracking\ValueTrackedItem.cs (1)

61document.Id,

ValueTracking\ValueTrackingService.cs (1)

41(service, solutionInfo, cancellationToken) => service.TrackValueSourceAsync(solutionInfo, selection, document.Id, cancellationToken),

Workspace\BackgroundParser.cs (5)

61=> CancelParse(args.Document.Id); 168CancelParse(document.Id); 192_workMap = _workMap.Add(document.Id, cancellationTokenSource); 221if (_workMap.TryGetValue(document.Id, out var sourceInMap) && sourceInMap == cancellationTokenSource) 223_workMap = _workMap.Remove(document.Id);

Workspace\CompileTimeSolutionProvider.cs (1)

172var compileTimeDocument = await compileTimeSolution.GetDocumentAsync(designTimeDocument.Id, includeSourceGenerated: true, cancellationToken).ConfigureAwait(false);

Extensions\Extensions.cs (1)

108var documentIdInCurrentContext = solution.Workspace.GetDocumentIdInCurrentContext(documents.First().Id);

Features\CodeCleanup\AbstractCodeCleanupService.cs (4)

191return solution.GetDocument(document.Id) ?? throw new NotSupportedException(FeaturesResources.Removal_of_document_not_supported); 262projectChanges.GetChangedDocuments().Any(documentId => documentId != updatedDocument.Id) || 263projectChanges.GetChangedAdditionalDocuments().Any(documentId => documentId != updatedDocument.Id) || 264projectChanges.GetChangedAnalyzerConfigDocuments().Any(documentId => documentId != updatedDocument.Id));

Features\CodeFixes\CodeFixService.cs (3)

107allDiagnostics.AddRange(buildOnlyDiagnosticsService.GetBuildOnlyDiagnostics(document.Id)); 184var buildOnlyDiagnostics = buildOnlyDiagnosticsService.GetBuildOnlyDiagnostics(document.Id); 317return (TDocument)(solution.GetTextDocument(document.Id) ?? throw new NotSupportedException(FeaturesResources.Removal_of_document_not_supported));

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

48var diagnostics = await _diagnosticService.GetDiagnosticsForIdsAsync(solution, null, document.Id, _diagnosticIds, _includeSuppressedDiagnostics, cancellationToken).ConfigureAwait(false);

Features\Diagnostics\DefaultDiagnosticAnalyzerService.cs (6)

95if (!_workspace.IsDocumentOpen(textDocument.Id)) 117if (!_workspace.IsDocumentOpen(document.Id)) 133DiagnosticsUpdatedArgs.DiagnosticsCreated(new DefaultUpdateArgsId(_workspace.Kind, kind, document.Id), 134_workspace, document.Project.Solution, document.Project.Id, document.Id, diagnosticData)); 206return RemoveDocumentAsync(document.Id, cancellationToken); 212return RemoveDocumentAsync(textDocument.Id, cancellationToken);

Features\Diagnostics\DocumentAnalysisExecutor.cs (5)

123(r, d, a, k) => $"Driver: {r != null}, {d.Id}, {d.Project.Id}, {a}, {k}", _compilationWithAnalyzers, textDocument, analyzer, kind); 135Logger.Log(FunctionId.Diagnostics_SemanticDiagnostic, (a, d, e) => $"{a}, ({d.Id}, {d.Project.Id}), Enabled:{e}", analyzer, textDocument, isEnabled); 209return result.GetDocumentDiagnostics(analysisScope.TextDocument.Id, analysisScope.Kind); 241? diagnosticAnalysisResult.GetDocumentDiagnostics(AnalysisScope.TextDocument.Id, AnalysisScope.Kind) 275? diagnosticAnalysisResult.GetDocumentDiagnostics(AnalysisScope.TextDocument.Id, AnalysisScope.Kind)

Features\Diagnostics\DocumentAnalysisExecutor_Helpers.cs (1)

417return documentIds.Any(static (id, targetTextDocument) => id == targetTextDocument.Id, targetTextDocument);

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

197CreateId(stateSet, document.Id, kind), 201document.Id, 249=> $"{title}: ({document.Id}, {document.Project.Id}), ({analyzer})";

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

48var state = stateSet.GetOrCreateActiveFileState(document.Id); 153var state = stateSet.GetOrCreateActiveFileState(document.Id); 473builder.AddExternalSyntaxDiagnostics(document.Id, await DocumentAnalysisExecutor.ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(documentAnalyzer, document, AnalysisKind.Syntax, compilation, cancellationToken).ConfigureAwait(false)); 474builder.AddExternalSemanticDiagnostics(document.Id, await DocumentAnalysisExecutor.ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(documentAnalyzer, document, AnalysisKind.Semantic, compilation, cancellationToken).ConfigureAwait(false)); 515lazyLoadDiagnostics.Add(document.Id, ImmutableArray.Create(DiagnosticData.Create(loadDiagnostic, document)));

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.IncrementalMemberEditAnalyzer.cs (4)

86var state = stateSet.GetOrCreateActiveFileState(document.Id); 125SaveMemberSpans(document.Id, version, newMemberSpans); 206|| lastDocument?.Id != document.Id)

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.IncrementalMemberEditAnalyzer_MemberSpans.cs (2)

31if (_savedMemberSpans.DocumentId == document.Id && _savedMemberSpans.Version == version) 39_savedMemberSpans = new MemberSpans(document.Id, version, memberSpans);

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

183documentAnalysisScope?.TextDocument.Id, 203var documentIds = (documentAnalysisScope != null) ? ImmutableHashSet.Create(documentAnalysisScope.TextDocument.Id) : null;

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

131if (IsEmpty(lastResult, document.Id)) 226await AddToInMemoryStorageAsync(serializerVersion, project, document, document.Id, _owner.SyntaxStateName, result.GetDocumentDiagnostics(document.Id, AnalysisKind.Syntax)).ConfigureAwait(false); 227await AddToInMemoryStorageAsync(serializerVersion, project, document, document.Id, _owner.SemanticStateName, result.GetDocumentDiagnostics(document.Id, AnalysisKind.Semantic)).ConfigureAwait(false); 228await AddToInMemoryStorageAsync(serializerVersion, project, document, document.Id, _owner.NonLocalStateName, result.GetDocumentDiagnostics(document.Id, AnalysisKind.NonLocal)).ConfigureAwait(false); 242Contract.ThrowIfFalse(state.DocumentId == document.Id); 280await AddToInMemoryStorageAsync(serializerVersion, project, document, document.Id, _owner.SyntaxStateName, syntax.Items).ConfigureAwait(false); 281await AddToInMemoryStorageAsync(serializerVersion, project, document, document.Id, _owner.SemanticStateName, semantic.Items).ConfigureAwait(false); 363var documentId = document.Id;

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer.StateSet.cs (6)

135projectState.IsEmpty(document.Id)) 144var activeFileState = GetOrCreateActiveFileState(document.Id); 146activeFileState.Save(AnalysisKind.Syntax, new DocumentAnalysisData(result.Version, result.GetDocumentDiagnostics(document.Id, AnalysisKind.Syntax))); 147activeFileState.Save(AnalysisKind.Semantic, new DocumentAnalysisData(result.Version, result.GetDocumentDiagnostics(document.Id, AnalysisKind.Semantic))); 156if (!_activeFileStates.TryRemove(document.Id, out var activeFileState)) 172if (TryGetActiveFileState(document.Id, out var activeFileState))

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

81AnalyzerService.Reanalyze(Workspace, documentIds: ImmutableArray.Create(activeDocument.Id), highPriority: true);

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer_GetDiagnosticsForSpan.cs (3)

290var state = stateSet.GetOrCreateActiveFileState(_document.Id); 364var state = stateSet.GetOrCreateActiveFileState(_document.Id); 430return diagnostic.DocumentId == _document.Id &&

Features\Diagnostics\EngineV2\DiagnosticIncrementalAnalyzer_IncrementalAnalyzer.cs (6)

42var isActiveDocument = _documentTrackingService.TryGetActiveDocument() == document.Id; 60var isVisibleDocument = _documentTrackingService.GetVisibleDocuments().Contains(document.Id); 113var state = stateSet.GetOrCreateActiveFileState(document.Id); 274RaiseDiagnosticsRemovedForDocument(document.Id, stateSets); 535var oldItems = oldResult.GetDocumentDiagnostics(document.Id, kind); 536var newItems = newResult.GetDocumentDiagnostics(document.Id, kind);

Handler\CodeLens\CodeLensResolveHandler.cs (1)

55var referenceCount = await codeLensReferencesService.GetReferenceCountAsync(document.Project.Solution, document.Id, memberToResolve.Node, maxSearchResults: 99, cancellationToken).ConfigureAwait(false);

Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (2)

238return new ProjectOrDocumentId(document.Id); 250return new ProjectOrDocumentId(additionalDocument.Id);

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

21public ProjectOrDocumentId GetId() => new(Document.Id);

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

64location: new DiagnosticDataLocation(i.Span, this.Document.Id, mappedFileSpan: i.MappedSpan)));

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

38Document.Project.Solution, Document.Project.Id, Document.Id, cancellationToken: cancellationToken).ConfigureAwait(false);

Handler\Highlights\DocumentHighlightHandler.cs (2)

98var highlightsForDocument = highlights.FirstOrDefault(h => h.Document.Id == document.Id);

Handler\ProjectContext\GetTextDocumentWithContextHandler.cs (2)

61var currentContextDocumentId = context.Workspace.GetDocumentIdInCurrentContext(openDocument.Id); 66DefaultIndex = documents.IndexOf(d => d.Id == currentContextDocumentId)

Handler\PullHandlers\VersionedPullCache`1.cs (2)

34documentToPreviousDiagnosticParams.ToDictionary(kvp => new ProjectOrDocumentId(kvp.Key.Id), kvp => kvp.Value), 35new ProjectOrDocumentId(document.Id),

Workspaces\LspWorkspaceManager.cs (2)

299lspSolution = lspSolution.WithDocumentText(workspaceDocuments.Select(d => d.Id), _trackedDocuments[uri]); 321_logger.LogWarning($"Text for {uriInWorkspace} did not match document text {firstDocument.Id} in workspace's {firstDocument.Project.Solution.WorkspaceKind} current solution");

Diagnostics\PullDiagnosticTests.cs (8)

322var rudeEdits = ImmutableArray.Create((document.Id, ImmutableArray.Create(new RudeEditDiagnostic(RudeEditKind.Update, default)))); 452testLspServer.TestWorkspace.GetTestDocument(csproj1Document.Id).GetTextBuffer(); 455testLspServer.TestWorkspace.SetDocumentContext(csproj2Document.Id); 466testLspServer.TestWorkspace.SetDocumentContext(csproj1Document.Id); 1214document.Id, TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create()))); 1306await testLspServer.TestWorkspace.ChangeDocumentAsync(csproj2Document.Id, newCsProj2Document.Project.Solution); 1381await testLspServer.TestWorkspace.ChangeDocumentAsync(csproj3Document.Id, newCsProj3Document.Project.Solution).ConfigureAwait(false); 1448await testLspServer.TestWorkspace.ChangeDocumentAsync(csproj2Document.Id, newCsProj2Document.Project.Solution);

Miscellaneous\LspMiscellaneousFilesWorkspaceTests.cs (2)

153Assert.True(miscWorkspace.CurrentSolution.ContainsDocument(miscDocument.Id)); 172Assert.False(miscWorkspace.CurrentSolution.ContainsDocument(miscDocument.Id));

Workspaces\LspWorkspaceManagerTests.cs (8)

69Assert.Same(testLspServer.TestWorkspace.CurrentSolution.GetDocument(firstDocument.Id), firstDocument); 70Assert.Same(testLspServer.TestWorkspace.CurrentSolution.GetDocument(secondDocument.Id), secondDocument); 74await testLspServer.TestWorkspace.ChangeDocumentAsync(firstDocument.Id, SourceText.From($"Some more text{markupOne}", System.Text.Encoding.UTF8, SourceHashAlgorithms.Default)); 89Assert.Equal(testLspServer.TestWorkspace.CurrentSolution.GetDocument(firstDocumentWithChange.Id), firstDocumentWithChange); 90Assert.Equal(testLspServer.TestWorkspace.CurrentSolution.GetDocument(secondDocumentUnchanged.Id), secondDocumentUnchanged); 108await testLspServer.TestWorkspace.ChangeDocumentAsync(secondDocument.Id, SourceText.From("Two is now three!", System.Text.Encoding.UTF8, SourceHashAlgorithms.Default)); 119Assert.NotEqual(testLspServer.TestWorkspace.CurrentSolution.GetDocument(secondDocument.Id), secondDocument); 230Assert.Equal(newDocumentId, document.Id);

Host\RemoteWorkspace.SolutionCreator.cs (10)

462TextDocumentKind.Document => document.Project.Solution.WithDocumentText(document.Id, sourceText).GetDocument(document.Id)!, 463TextDocumentKind.AnalyzerConfigDocument => document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, sourceText).GetAnalyzerConfigDocument(document.Id)!, 464TextDocumentKind.AdditionalDocument => document.Project.Solution.WithAdditionalDocumentText(document.Id, sourceText).GetAdditionalDocument(document.Id)!, 487document = document.Project.Solution.WithDocumentFolders(document.Id, newDocumentInfo.Folders).GetDocument(document.Id)!; 494document = document.Project.Solution.WithDocumentSourceCodeKind(document.Id, newDocumentInfo.SourceCodeKind).GetDocument(document.Id)!;

Services\DiagnosticAnalyzer\DiagnosticComputer.cs (1)

110document = project.GetTextDocument(document.Id);

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

99var groups = documents.GroupBy(d => d.document.Id);

Services\SymbolFinder\RemoteSymbolFinderService.cs (3)

190=> _callback.InvokeAsync((callback, cancellationToken) => callback.OnLiteralReferenceFoundAsync(_callbackId, document.Id, span, cancellationToken), cancellationToken); 222=> _callback.InvokeAsync((callback, cancellationToken) => callback.OnFindInDocumentStartedAsync(_callbackId, document.Id, cancellationToken), cancellationToken); 225=> _callback.InvokeAsync((callback, cancellationToken) => callback.OnFindInDocumentCompletedAsync(_callbackId, document.Id, cancellationToken), cancellationToken);

Services\UnitTesting\RemoteUnitTestingSearchService.cs (2)

44new DocumentIdSpan(result.DocumentSpan.Document.Id, result.DocumentSpan.SourceSpan), 62new DocumentIdSpan(r.DocumentSpan.Document.Id, r.DocumentSpan.SourceSpan),

NonSourceFileRefactoring.cs (2)

32return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); 33return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText);

LineCommit\CommitCommandHandler.vb (1)

244If formattingRuleService.ShouldNotFormatOrCommitOnPaste(document.Id) Then

LineCommit\CommitFormatter.vb (1)

77document.Id,

NavigationBar\VisualBasicEditorNavigationBarItemService_CodeGeneration.vb (1)

45solution.Workspace, solution.GetRequiredDocument(navigationPoint.Tree).Id,

CodeActions\Preview\PreviewTests.vb (1)

62solution = solution.WithDocumentSyntaxRoot(_oldDocument.Id, VisualBasicSyntaxTree.ParseText(s_changedDocumentText).GetRoot())

EditAndContinue\VisualBasicEditAndContinueAnalyzerTests.vb (4)

474Dim documentId = oldDocument.Id 560Dim documentId = oldDocument.Id 618Dim documentId = oldDocument.Id 649Dim documentId = oldProject.Documents.Single().Id

Formatting\CodeCleanUpTests.vb (2)

660solution = solution.WithDocumentText(document.Id, Await document.GetTextAsync()) 705solution = solution.WithDocumentText(document.Id, Await document.GetTextAsync())

GenerateType\VisualBasicGenerateTypeService.vb (1)

677updatedSolution = updatedSolution.WithDocumentSyntaxRoot(document.Id, addedCompilationRoot, PreservationMode.PreserveIdentity)

IntroduceVariable\VisualBasicIntroduceVariableService_IntroduceField.vb (1)

100updatedDocument = updatedDocument.Project.Solution.GetDocument(currentDocument.Id).WithSyntaxRoot(newRoot)

Rename\VisualBasicRenameRewriterLanguageService.vb (1)

107_documentId = parameters.Document.Id

Classification\AbstractClassificationService.cs (1)

83solutionInfo, document.Id, textSpan, type, options, isFullyLoaded, cancellationToken),

Classification\SemanticClassificationCacheUtilities.cs (1)

24var documentKey = new DocumentKey(projectKey, document.Id, document.FilePath, document.Name);

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (1)

209foreach (var group in allChangedDocumentsInDiagnosticsOrder.GroupBy(d => d.Id))

CodeFixes\FixAllOccurrences\DocumentBasedFixAllProvider.cs (1)

134return (document.Id, (node, text));

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (2)

45Debug.Assert(newDocument.Id == _oldDocument.Id);

CodeFixesAndRefactorings\DocumentBasedFixAllProviderHelpers.cs (1)

115return (dirtyDocument.Id, cleanedText);

CodeRefactorings\FixAllOccurences\DocumentBasedFixAllProvider.cs (1)

116return (document.Id, (node, text));

Diagnostics\DiagnosticAnalysisResultBuilder.cs (2)

118map.GetOrAdd(document.Id, _ => new List<DiagnosticData>()).Add(DiagnosticData.Create(diagnostic, document)); 121_lazyDocumentsWithDiagnostics.Add(document.Id);

Diagnostics\DiagnosticData.cs (2)

197return new DiagnosticDataLocation(originalLineInfo, document?.Id, mappedLineInfo); 204diagnosticSpanMappingService.GetAdjustedDiagnosticSpan(document.Id, location, out _, out originalLineInfo, out mappedLineInfo);

Diagnostics\Extensions.cs (1)

146tree: null, documentAnalysisScope.TextDocument.Id, spanToAnalyze, AnalysisKind.Syntax, diagnosticIdsToFilter, includeSuppressedDiagnostics);

DocumentExtensions.cs (1)

80return workspace != null && workspace.IsDocumentOpen(document.Id);

Editing\SolutionEditor.cs (1)

54var currentDoc = changedSolution.GetDocument(docEd.OriginalDocument.Id);

Editing\SymbolEditor.cs (3)

330return EditOneDeclarationAsync(symbol, doc.Id, location.SourceSpan.Start, editAction, cancellationToken); 375return doc != null && doc.Id == documentId && d.FullSpan.IntersectsWith(position); 461var declsByDocId = this.GetDeclarations(currentSymbol).ToLookup(d => _currentSolution.GetDocument(d.SyntaxTree).Id);

FindSymbols\ReferenceLocation.cs (3)

130EqualityComparer<DocumentId>.Default.Equals(this.Document.Id, other.Document.Id) && 141Hash.Combine(this.Location, this.Document.Id.GetHashCode()))));

FindSymbols\Shared\AbstractSyntaxIndex.cs (3)

64s_documentIdToIndex.Remove(document.Id); 65s_documentIdToIndex.GetValue(document.Id, _ => index); 85if (s_documentIdToIndex.TryGetValue(document.Id, out var index) &&

FindSymbols\SymbolFinder_FindReferences_Current.cs (1)

51var documentIds = documents?.SelectAsArray(d => d.Id) ?? default;

LinkedFileDiffMerging\LinkedFileDiffMergingSession.cs (2)

50var allLinkedDocuments = documentInNewSolution.GetLinkedDocumentIds().Add(documentInNewSolution.Id); 217oldDocument.Id));

ParsedDocument.cs (2)

38return new ParsedDocument(document.Id, text, root, document.Project.GetExtendedLanguageServices()); 46return new ParsedDocument(document.Id, text, root, document.Project.GetExtendedLanguageServices());

Remote\RemoteArguments.cs (1)

180referenceLocation.Document.Id,

Rename\ConflictEngine\ConflictResolver.cs (4)

195implicitUsageConflict.SourceSpan, conflictResolution.OldSolution.GetRequiredDocument(implicitUsageConflict.SourceTree).Id, RelatedLocationType.UnresolvableConflict)); 219implicitConflict.SourceSpan, conflictResolution.OldSolution.GetRequiredDocument(implicitConflict.SourceTree).Id, RelatedLocationType.UnresolvableConflict)); 312languageConflict.SourceSpan, conflictResolution.OldSolution.GetRequiredDocument(languageConflict.SourceTree).Id, RelatedLocationType.UnresolvableConflict)); 339oldLocation.SourceSpan, conflictResolution.OldSolution.GetRequiredDocument(oldLocation.SourceTree).Id, RelatedLocationType.UnresolvableConflict));

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

68_documentIdOfRenameSymbolDeclaration = renameLocationSet.Solution.GetRequiredDocument(renameSymbolDeclarationLocation.SourceTree!).Id; 705documentIds.AddRange(allRenamedDocuments.Select(d => d.Id)); 733if (documentIds.Contains(document.Id)) 742documentIds.Add(document.Id); 748documentIds.Add(document.Id); 756documentIds.Add(document.Id);

Rename\ConflictEngine\MutableConflictResolution.cs (1)

138_renamedDocument = (document.Id, newName);

Rename\Renamer.cs (2)

122return new RenameDocumentActionSet(ImmutableArray<RenameDocumentAction>.Empty, document.Id, document.Name, document.Folders.ToImmutableArray(), options); 144document.Id,

Rename\Renamer.RenameDocumentActionSet.cs (1)

93var documentId = document.Id;

Rename\RenameUtilities.cs (1)

94.Concat(documentsOfRenameSymbolDeclaration.First().Id)

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (8)

227results.Add(new RenameLocation(location, document.Id, isRenamableAccessor: isRenamableAccessor)); 261results.Add(new RenameLocation(location, location.Document.Id)); 267results.Add(new RenameLocation(aliasLocation, solution.GetRequiredDocument(aliasLocation.SourceTree).Id)); 280results.Add(new RenameLocation(location.Location, location.Document.Id, 286results.Add(new RenameLocation(aliasLocation, solution.GetRequiredDocument(aliasLocation.SourceTree).Id)); 294location.Document.Id, 302location.Document.Id, 417var renameLocation = new RenameLocation(matchLocation, document.Id, containingLocationForStringOrComment: containingSpan);

SemanticModelReuse\SemanticModelWorkspaceServiceFactory.SemanticModelWorkspaceService.cs (6)

117if (originalMap.TryGetValue(document.Id, out var reuseInfoOpt) && 129var info = updatedMap[document.Id]!.Value; 151return map.SetItem(document.Id, reuseInfo.Value); 161builder.Add(document.Id, new SemanticModelReuseInfo(semanticModel, semanticModel, bodyNode, topLevelSemanticVersion)); 181if (!map.ContainsKey(document.Id)) 185if (!map.TryGetValue(document.Id, out var reuseInfoOpt) || !reuseInfoOpt.HasValue)

Shared\Extensions\DocumentExtensions.cs (1)

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

TextDocumentExtensions.cs (4)

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

Workspace\Solution\Document.cs (18)

325=> this.Project.Solution.WithDocumentSourceCodeKind(this.Id, kind).GetDocument(this.Id)!; 331=> this.Project.Solution.WithDocumentText(this.Id, text, PreservationMode.PreserveIdentity).GetDocument(this.Id)!; 337=> this.Project.Solution.WithDocumentSyntaxRoot(this.Id, root, PreservationMode.PreserveIdentity).GetDocument(this.Id)!; 343=> this.Project.Solution.WithDocumentName(this.Id, name).GetDocument(this.Id)!; 349=> this.Project.Solution.WithDocumentFolders(this.Id, folders).GetDocument(this.Id)!; 359=> this.Project.Solution.WithDocumentFilePath(this.Id, filePath).GetDocument(this.Id)!; 377if (this.Id != oldDocument.Id) 433var filteredDocumentIds = this.Project.Solution.GetRelatedDocumentIds(this.Id); 434return filteredDocumentIds.Remove(this.Id); 455var newSolution = this.Project.Solution.WithFrozenPartialCompilationIncludingSpecificDocument(this.Id, cancellationToken); 456return newSolution.GetDocument(this.Id)!;

Workspace\Workspace.cs (2)

270newSolution = UpdateAddedDocumentToExistingContentsInSolution(newSolution, addedDocument.Id); 1775doc.Id,

Workspace\Workspace_Editor.cs (3)

448CheckDocumentIsOpen(document.Id); 450Contract.ThrowIfFalse(_openSourceGeneratedDocumentIdentities.Remove(document.Id)); 451ClearOpenDocument(document.Id);

MSBuild\MSBuildWorkspace.cs (3)

376_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, message, document.Id)); 394_reporter.Report(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, message, document.Id)); 501this.DeleteDocumentFile(document.Id, document.FilePath);

VisualStudioMSBuildWorkspaceTests.cs (12)

383var solution1 = solution.WithDocumentText(document.Id, SourceText.From("using test;")); 384var document1 = solution1.GetDocument(document.Id); 397var document2 = solution2.GetDocument(document.Id); 2046workspace.TryApplyChanges(solution.WithDocumentText(document.Id, newText, PreservationMode.PreserveIdentity)); 2079workspace.RemoveDocument(document.Id); 2106var newSolution = solution.WithDocumentText(document.Id, newText); 2112var document2 = solution2.GetDocument(document.Id); 2133var newSolution = solution.WithAdditionalDocumentText(document.Id, newText); 2139var document2 = solution2.GetAdditionalDocument(document.Id); 2204workspace.TryApplyChanges(workspace.CurrentSolution.RemoveAdditionalDocument(xaml.Id)); 2230workspace.TryApplyChanges(workspace.CurrentSolution.WithDocumentText(doc.Id, SourceText.From(newText), PreservationMode.PreserveIdentity)); 2264doc.Id,

Formatter\FormatterTests.cs (3)

79document = document.Project.Solution.WithOptions(solutionOptions).GetRequiredDocument(document.Id); 129var csDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(csDocument.Id); 130var vbDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(vbDocument.Id);

Simplifier\SimplifierTests.cs (2)

93var csDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(csDocument.Id); 94var vbDocumentWithUpdatedOptions = solutionWithUpdatedOptions.GetRequiredDocument(vbDocument.Id);

SolutionTests\SolutionTests.cs (9)

3056var doc2 = doc.Project.Solution.WithDocumentSyntaxRoot(doc.Id, newRoot, PreservationMode.PreserveValue).GetDocument(doc.Id); 3466var solution = project.Solution.WithDocumentText(documentToFreezeOriginal.Id, SourceText.From("class DocumentToFreeze { void M() { /*no top level change*/ } }")); 3467var documentToFreezeChanged = solution.GetDocument(documentToFreezeOriginal.Id); 3511var solution = project.Solution.WithDocumentText(documentToFreezeOriginal.Id, SourceText.From("class DocumentToFreeze { void M() { } public void NewMethod() { } }")); 3512var documentToFreezeChanged = solution.GetDocument(documentToFreezeOriginal.Id); 4310var newDoc = doc.Project.Solution.WithDocumentSyntaxRoot(doc.Id, newRoot).GetDocument(doc.Id); 4342static (sourceText, document) => document.Project.Solution.WithDocumentText(document.Id, sourceText, PreservationMode.PreserveIdentity),

SolutionTests\SolutionWithSourceGeneratorTests.cs (9)

163Assert.NotEqual(generatedDocuments[0].Id, generatedDocuments[1].Id); 362Assert.Equal(generatedDocumentBeforeChange.Id, generatedDocumentAfterChange.Id); 383Assert.NotEqual(generatedDocumentsInFirstProject.Single().Id.Id, generatedDocumentsInSecondProject.Single().Id.Id); 623workspace.OnAdditionalDocumentRemoved(originalAdditionalFile.Id); 770var documentIdsToTest = new[] { originalDocument1.Id, originalDocument2.Id };

SymbolKeyTests.cs (2)

806document = workspace.CurrentSolution.GetDocument(document.Id); 853document = workspace.CurrentSolution.GetDocument(document.Id);

WorkspaceTests\AdhocWorkspaceTests.cs (11)

402var docid1 = ws.AddDocument(projid, "A.cs", SourceText.From("public class A { }")).Id; 403var docid2 = ws.AddDocument(projid, "B.cs", SourceText.From("public class B { }")).Id; 450&& args.DocumentId == originalDoc.Id) 458var appliedDoc = ws.CurrentSolution.GetDocument(originalDoc.Id); 483&& args.DocumentId == originalDoc.Id) 491var appliedDoc = ws.CurrentSolution.GetDocument(originalDoc.Id); 517&& args.DocumentId == originalDoc.Id) 525var appliedDoc = ws.CurrentSolution.GetDocument(originalDoc.Id); 548&& args.DocumentId == originalDoc.Id) 556var appliedDoc = ws.CurrentSolution.GetDocument(originalDoc.Id); 586var appliedDoc = ws.CurrentSolution.GetDocument(originalDoc.Id);

CallHierarchy\CallHierarchyDetail.cs (1)

84_provider.ThreadingContext, _workspace, document.Id, _span,

CodeLens\CodeLensCallbackListener.cs (1)

165return (document.Id, root.FindNode(textSpan));

DebuggerIntelliSense\AbstractDebuggerIntelliSenseContext.cs (2)

174var forkedSolution = solution.WithDocumentText(document.Id, _projectionBuffer.CurrentSnapshot.AsText(), PreservationMode.PreserveIdentity); 183_workspace.OpenDocument(document.Id, _projectionBuffer.AsTextContainer());

FindReferences\Entries\DocumentSpanEntry.cs (1)

313_excerptResult.Document.Id,

Implementation\VisualStudioSupportsFeatureService.cs (5)

94=> SupportsCodeFixesWorker(document.Id); 97=> SupportsRefactoringsWorker(document.Id); 100=> SupportsRenameWorker(document.Project.Solution.GetRelatedDocumentIds(document.Id)); 103=> SupportsSemanticSnippetsWorker(document.Id); 106=> SupportsNavigationToAnyPositionWorker(document.Id);

LanguageService\AbstractLanguageService`2.IVsLanguageTextOps.cs (1)

77var formattedChanges = ruleFactory.FilterFormattedChanges(document.Id, originalSpan, originalChanges);

LanguageService\AbstractLanguageService`2.VsLanguageDebugInfo.cs (2)

237var filePath = _languageService.Workspace.GetFilePath(document.Id); 243_threadingContext, document.Id, cancellationToken).ConfigureAwait(false);

NavigateTo\VisualStudioNavigateToPreviewService.cs (1)

30=> ContainedDocument.TryGetContainedDocument(document.Id) == null;

Preview\FileChange.cs (5)

48this.Id = left != null ? left.Id : right.Id; 94return GetChangeList(diff, right.Id, oldText, newText); 127var entireSpanChild = new SpanChange(entireSpan, _buffer, document.Id, displayText, text, text, isDeletion: false, parent: this, engine: engine); 223if (vsWorkspace.TryGetImageListAndIndex(_imageService, document.Id, out pData[0].hImageList, out pData[0].Image))

Preview\PreviewUpdater.cs (3)

56if (document.Id == _currentDocumentId) 77_currentDocumentId = document.Id; 79_previewWorkspace.OpenDocument(document.Id, container);

Preview\PreviewUpdater.PreviewDialogWorkspace.cs (3)

30OnDocumentClosed(document.Id, new PreviewTextLoader(text)); 34OnAnalyzerConfigDocumentClosed(document.Id, new PreviewTextLoader(text)); 38OnAdditionalDocumentClosed(document.Id, new PreviewTextLoader(text));

Preview\TopLevelChange.cs (6)

80ApplyFileChangesCore(oldTextDocument, updatedTextDocument?.Id, updatedDocumentTextOpt, 91var newLinkedDocumentIdOpt = updatedDocumentTextOpt != null ? oldLinkedDocument.Id : null; 156solution = solution.AddDocument(oldDocument.Id, oldDocument.Name, oldText, oldDocument.Folders, oldDocument.FilePath); 160solution = solution.AddAnalyzerConfigDocument(oldDocument.Id, oldDocument.Name, SourceText.From(oldText), oldDocument.Folders, oldDocument.FilePath); 164solution = solution.AddAdditionalDocument(oldDocument.Id, oldDocument.Name, oldText, oldDocument.Folders, oldDocument.FilePath); 174Debug.Assert(oldDocument.Id == updatedDocumentIdOpt);

Progression\GraphBuilder.cs (2)

216node[RoslynGraphProperties.ContextDocumentId] = contextDocument.Id; 758symbolNode[RoslynGraphProperties.ContextDocumentId] = document.Id;

Progression\GraphNavigatorExtension.cs (1)

104document.Id,

ProjectSystem\VisualStudioWorkspaceImpl.cs (2)

1239if (document.Id != updatedInfo.Id) 1242$"This Workspace does not support changing a document's {nameof(document.Id)}.");

Snippets\AbstractSnippetExpansionClient.cs (1)

1122var containedDocument = ContainedDocument.TryGetContainedDocument(document.Id);

StackTraceExplorer\StackFrameViewModel.cs (1)

135_threadingContext, _workspace, document.Id, lineNumber - 1, offset: 0, options, cancellationToken).ConfigureAwait(false);

TableDataSource\AbstractTableEntriesSnapshot.cs (1)

193documentId = documents.FirstOrDefault(document => Path.Combine(projectDirectory, document.FilePath) == item.GetOriginalFilePath())?.Id;

TableDataSource\OpenDocumentTracker.cs (1)

116=> StopTracking(e.Document.Id);

TableDataSource\Suppression\VisualStudioDiagnosticListSuppressionStateService.cs (1)

300new FileLinePositionSpan(filePath, linePositionSpan), document.Id);

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (2)

476var document = newSolution.GetDocument(oldDocument.Id); 572if (!latestDocumentDiagnosticsMap.TryGetValue(document.Id, out var latestDocumentDiagnostics))

TableDataSource\VisualStudioDiagnosticListTable.BuildTableDataSource.cs (2)

252if (documents.Any(document => document.Id == documentId)) 258documentId = documents.FirstOrDefault(document => Path.Combine(projectDirectory, document.FilePath) == item.GetOriginalFilePath())?.Id;

TaskList\TaskListIncrementalAnalyzer.cs (3)

87if (!_documentsWithTaskListItems.Remove(document.Id)) 93_documentsWithTaskListItems.Add(document.Id); 97await _listener.ReportTaskListItemsAsync(document.Id, items, cancellationToken).ConfigureAwait(false);

Venus\ContainedDocument.cs (3)

191return document.Id; 203if (document.Id == this.Id) 208return hierarchy.TryGetItemId(_workspace.CurrentSolution.GetDocument(document.Id).FilePath);

Workspace\SourceGeneratedFileManager.cs (3)

101if (!_directoryInfoOnDiskByContainingDirectoryId.ContainsKey(document.Id.Id)) 103_directoryInfoOnDiskByContainingDirectoryId.Add(document.Id.Id, document.Identity); 110document.Id.Id.ToString(),

Workspace\VisualStudioSymbolNavigationService.cs (2)

80solution.Workspace, targetDocument.Id, sourceLocation.SourceSpan, 178openedDocument.Id,

CodeModel\FileCodeModelTestHelpers.cs (1)

37var document = project.Documents.Single().Id;

CodeModel\AbstractCodeModelService.cs (2)

603chosenDocumentId = document.Id; 608generatedCode ??= Tuple.Create(document.Id, location);

CodeModel\Collections\OverloadsCollection.cs (1)

77var fileCodeModelObject = this.Workspace.GetFileCodeModel(document.Id);

CodeModel\Collections\PartialTypeCollection.cs (1)

60var fileCodeModelObject = this.Workspace.GetFileCodeModel(document.Id);

CodeModel\ProjectCodeModel.cs (1)

124return FileCodeModel.Create(GetCodeModelCache().State, parent: null, sourceGeneratedDocument.Id, isSourceGeneratorOutput: true, new TextManagerAdapter()).Handle;

Options\AbstractOptionPreviewViewModel.cs (1)

159workspace.OpenDocument(document.Id, container);

RoslynVisualStudioWorkspace.cs (1)

167var vsFileCodeModel = this.GetFileCodeModel(document.Id);

SolutionExplorer\SourceGeneratedFileItems\SourceGeneratedFileItemSource.cs (2)

80.ToDictionary(d => d.Id); 148_threadingContext, document.Id, document.HintName, document.Project.Language, _workspace));

Client\RemoteLanguageServiceWorkspace.cs (2)

236OnDocumentOpened(document.Id, textContainer); 237_openedDocs = _openedDocs.SetItem(moniker, document.Id);

Diagnostics\DefaultDiagnosticUpdateSourceTests.vb (6)

107workspace, document.Project.Id, document.Id, Nothing, includeSuppressedDiagnostics:=False, CancellationToken.None) 145workspace, document.Project.Id, document.Id, Nothing, includeSuppressedDiagnostics:=False, CancellationToken.None) 184workspace, document.Project.Id, document.Id, Nothing, includeSuppressedDiagnostics:=False, CancellationToken.None) 220Await analyzer.RemoveDocumentAsync(document.Id, CancellationToken.None) 226workspace, document.Project.Id, document.Id, Nothing, includeSuppressedDiagnostics:=False, CancellationToken.None) 329workspace, document.Project.Id, document.Id, Nothing, includeSuppressedDiagnostics:=False, CancellationToken.None)

Diagnostics\DiagnosticTableDataSourceTests.vb (2)

681Dim diagnostic1 = CreateItem(workspace.CurrentSolution, document1.Id) 682Dim diagnostic2 = CreateItem(workspace.CurrentSolution, document2.Id)

Diagnostics\ExternalDiagnosticUpdateSourceTests.vb (6)

525New FileLinePositionSpan(document.FilePath, New LinePositionSpan()), document.Id), 532Assert.Equal(document.Id, args.DocumentId) 545source.AddNewErrors(document.Id, diagnostic) 559Dim buildOnlyDiagnostic = Assert.Single(buildOnlyDiagnosticService.GetBuildOnlyDiagnostics(document.Id)) 565oldSolution:=workspace.CurrentSolution, newSolution:=document.Project.Solution, project.Id, document.Id)) 570Assert.Empty(buildOnlyDiagnosticService.GetBuildOnlyDiagnostics(document.Id))

SolutionExplorer\SourceGeneratorItemTests.vb (1)

89Assert.Equal(sourceGeneratedDocument.Id, fileItem.DocumentId)

Venus\DocumentService_IntegrationTests.vb (5)

147Dim results = Await codelensService.FindReferenceLocationsAsync(workspace.CurrentSolution, startDocument.Id, node, CancellationToken.None) 200Dim currentDocument = workspace.CurrentSolution.GetDocument(document.Id) 241Dim diagnostics = Await diagnosticService.GetDiagnosticsAsync(workspace.CurrentSolution, documentId:=document.Id) 272Dim testDocument = testWorkspace.GetTestDocument(document.Id) 310Dim testDocument = testWorkspace.GetTestDocument(document.Id)

Venus\ContainedLanguageStaticEventBinding.vb (4)

74Using visualStudioWorkspace.OpenInvisibleEditor(targetDocument.Id) 75targetDocument = visualStudioWorkspace.CurrentSolution.GetDocument(targetDocument.Id) 102Using visualStudioWorkspace.OpenInvisibleEditor(targetDocument.Id) 103targetDocument = visualStudioWorkspace.CurrentSolution.GetDocument(targetDocument.Id)

Features\InlineRename\XamlEditorInlineRenameService.cs (2)

166newSolution = newSolution.WithDocumentText(document.Id, newSource); 186public IEnumerable<DocumentId> DocumentIds => _inlineRenameLocationSet.Locations.Select(l => l.Document.Id).Distinct();

Implementation\LanguageServer\Handler\Completion\CompletionHandler.cs (1)

76Items = completionResult.Completions.Select(c => CreateCompletionItem(c, document.Id, text, request.Position, request.TextDocument, commitCharactersCache)).ToArray(),

Panels\WorkspacePanel.xaml.cs (1)

84where !workspace.IsDocumentOpen(document.Id)

Remote\RemoteHostClientServiceFactoryTests.cs (1)

57var newSolution = document.Project.Solution.WithDocumentText(document.Id, newText, PreservationMode.PreserveIdentity);

Services\ServiceHubServicesTests.cs (3)

88(service, cancellationToken) => service.SynchronizeTextAsync(oldDocument.Id, oldState.Text, newText.GetTextChanges(oldText), cancellationToken), 154Assert.Equal(solution.Projects.Single().Documents.Single().Id, info.DocumentId); 396var documentIds = documents.SelectAsArray(document => document.Id);

Services\SolutionServiceTests.cs (4)

208await VerifySolutionUpdate(code, s => s.WithDocumentFolders(s.Projects.First().Documents.First().Id, new[] { "test" })); 370remoteSolution = remoteSolution.WithDocumentText(remoteSolution.Projects.First().Documents.First().Id, SourceText.From(code + " class Test2 { }")); 396var currentSolution = remoteSolution1.WithDocumentText(remoteSolution1.Projects.First().Documents.First().Id, SourceText.From(code + " class Test2 { }")); 405currentSolution = oopSolution2.WithDocumentText(oopSolution2.Projects.First().Documents.First().Id, SourceText.From(code + " class Test3 { }"));