internal TextDocument(Project project, TextDocumentState state) { Contract.ThrowIfNull(project); Contract.ThrowIfNull(state); this.Project = project; State = state; }
public ProjectState AddAdditionalDocument(TextDocumentState document) { Debug.Assert(!this.AdditionalDocumentStates.ContainsKey(document.Id)); return(this.With( projectInfo: this.ProjectInfo.WithVersion(this.Version.GetNewerVersion()), additionalDocumentIds: _additionalDocumentIds.Add(document.Id), additionalDocumentStates: _additionalDocumentStates.Add(document.Id, document))); }
private AsyncLazy <VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion( TextDocumentState newDocument, IImmutableDictionary <DocumentId, DocumentState> newDocumentStates, IImmutableDictionary <DocumentId, TextDocumentState> newAdditionalDocumentStates) { if (_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out var oldVersion)) { return(new AsyncLazy <VersionStamp>(c => ComputeTopLevelChangeTextVersionAsync(oldVersion, newDocument, c), cacheResult: true)); } else { return(new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true)); } }
public ProjectState UpdateAdditionalDocument(TextDocumentState newDocument, bool textChanged, bool recalculateDependentVersions) { Debug.Assert(this.ContainsAdditionalDocument(newDocument.Id)); var oldDocument = this.GetAdditionalDocumentState(newDocument.Id); if (oldDocument == newDocument) { return(this); } var newDocumentStates = _additionalDocumentStates.SetItem(newDocument.Id, newDocument); GetLatestDependentVersions( _documentStates, newDocumentStates, oldDocument, newDocument, recalculateDependentVersions, textChanged, out var dependentDocumentVersion, out var dependentSemanticVersion); return(this.With( additionalDocumentStates: newDocumentStates, latestDocumentVersion: dependentDocumentVersion, latestDocumentTopLevelChangeVersion: dependentSemanticVersion)); }
private void GetLatestDependentVersions( IImmutableDictionary <DocumentId, DocumentState> newDocumentStates, IImmutableDictionary <DocumentId, TextDocumentState> newAdditionalDocumentStates, TextDocumentState oldDocument, TextDocumentState newDocument, bool recalculateDependentVersions, bool textChanged, out AsyncLazy <VersionStamp> dependentDocumentVersion, out AsyncLazy <VersionStamp> dependentSemanticVersion) { var recalculateDocumentVersion = false; var recalculateSemanticVersion = false; if (recalculateDependentVersions) { if (oldDocument.TryGetTextVersion(out var oldVersion)) { if (!_lazyLatestDocumentVersion.TryGetValue(out var documentVersion) || documentVersion == oldVersion) { recalculateDocumentVersion = true; } if (!_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out var semanticVersion) || semanticVersion == oldVersion) { recalculateSemanticVersion = true; } } } dependentDocumentVersion = recalculateDocumentVersion ? new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true) : textChanged ? new AsyncLazy <VersionStamp>(newDocument.GetTextVersionAsync, cacheResult: true) : _lazyLatestDocumentVersion; dependentSemanticVersion = recalculateSemanticVersion ? new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true) : textChanged? CreateLazyLatestDocumentTopLevelChangeVersion(newDocument, newDocumentStates, newAdditionalDocumentStates) : _lazyLatestDocumentTopLevelChangeVersion; }
public ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServices, SolutionServices solutionServices) { Contract.ThrowIfNull(projectInfo); Contract.ThrowIfNull(languageServices); Contract.ThrowIfNull(solutionServices); _languageServices = languageServices; _solutionServices = solutionServices; var projectInfoFixed = FixProjectInfo(projectInfo); _documentIds = projectInfoFixed.Documents.Select(d => d.Id).ToImmutableList(); _additionalDocumentIds = projectInfoFixed.AdditionalDocuments.Select(d => d.Id).ToImmutableList(); var parseOptions = projectInfoFixed.ParseOptions; var docStates = ImmutableSortedDictionary.CreateRange(DocumentIdComparer.Instance, projectInfoFixed.Documents.Select(d => new KeyValuePair <DocumentId, DocumentState>(d.Id, CreateDocument(d, parseOptions, languageServices, solutionServices)))); _documentStates = docStates; var additionalDocStates = ImmutableSortedDictionary.CreateRange(DocumentIdComparer.Instance, projectInfoFixed.AdditionalDocuments.Select(d => new KeyValuePair <DocumentId, TextDocumentState>(d.Id, TextDocumentState.Create(d, solutionServices)))); _additionalDocumentStates = additionalDocStates; _lazyLatestDocumentVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentVersionAsync(docStates, additionalDocStates, c), cacheResult: true); _lazyLatestDocumentTopLevelChangeVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(docStates, additionalDocStates, c), cacheResult: true); // ownership of information on document has moved to project state. clear out documentInfo the state is // holding on. otherwise, these information will be held onto unnecesarily by projectInfo even after // the info has changed by DocumentState. // we hold onto the info so that we don't need to duplicate all information info already has in the state _projectInfo = ClearAllDocumentsFromProjectInfo(projectInfoFixed); _lazyChecksums = new AsyncLazy <ProjectStateChecksums>(ComputeChecksumsAsync, cacheResult: true); }
private static async Task <VersionStamp> ComputeTopLevelChangeTextVersionAsync(VersionStamp oldVersion, TextDocumentState newDocument, CancellationToken cancellationToken) { var newVersion = await newDocument.GetTopLevelChangeTextVersionAsync(cancellationToken).ConfigureAwait(false); return(newVersion.GetNewerVersion(oldVersion)); }