private AsyncLazy <VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion( TextDocumentState newDocument, TextDocumentStates <DocumentState> newDocumentStates, TextDocumentStates <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) { Contract.Requires(this.ContainsAdditionalDocument(newDocument.Id)); var oldDocument = this.GetAdditionalDocumentState(newDocument.Id); if (oldDocument == newDocument) { return(this); } var newDocumentStates = this.AdditionalDocumentStates.SetItem(newDocument.Id, newDocument); AsyncLazy <VersionStamp> dependentDocumentVersion; AsyncLazy <VersionStamp> dependentSemanticVersion; GetLatestDependentVersions( this.documentStates, newDocumentStates, oldDocument, newDocument, recalculateDependentVersions, textChanged, out dependentDocumentVersion, out dependentSemanticVersion); return(this.With( additionalDocumentStates: newDocumentStates, latestDocumentVersion: dependentDocumentVersion, latestDocumentTopLevelChangeVersion: dependentSemanticVersion)); }
internal TextDocument(Project project, TextDocumentState state) { Contract.ThrowIfNull(project); Contract.ThrowIfNull(state); this.Project = project; State = state; }
#pragma warning restore IDE0052 // Remove unread private members public TouchAdditionalDocumentAction( TextDocumentState oldState, TextDocumentState newState ) { _oldState = oldState; _newState = newState; }
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))); }
public bool HasTextChanged(TextDocumentState oldState, bool ignoreUnchangeableDocument) { if (ignoreUnchangeableDocument && !oldState.CanApplyChange()) { return(false); } return(oldState.TextAndVersionSource != TextAndVersionSource); }
public ProjectState AddAdditionalDocument(TextDocumentState document) { Contract.Requires(!this.AdditionalDocumentStates.ContainsKey(document.Id)); return(this.With( projectInfo: this.ProjectInfo.WithVersion(this.Version.GetNewerVersion()).WithAdditionalDocuments(this.ProjectInfo.AdditionalDocuments.Concat(document.Info)), additionalDocumentIds: this.AdditionalDocumentIds.ToImmutableArray().Add(document.Id), additionalDocumentStates: this.AdditionalDocumentStates.Add(document.Id, document))); }
private static async Task <VersionStamp> ComputeTopLevelChangeTextVersionAsync( VersionStamp oldVersion, TextDocumentState newDocument, CancellationToken cancellationToken ) { var newVersion = await newDocument .GetTopLevelChangeTextVersionAsync(cancellationToken) .ConfigureAwait(false); return(newVersion.GetNewerVersion(oldVersion)); }
private AsyncLazy <VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion( TextDocumentState newDocument, ImmutableDictionary <DocumentId, DocumentState> newDocumentStates, ImmutableDictionary <DocumentId, TextDocumentState> newAdditionalDocumentStates) { VersionStamp oldVersion; if (this.lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out oldVersion)) { return(new AsyncLazy <VersionStamp>(c => ComputeTopLevelChangeTextVersionAsync(oldVersion, newDocument, c), cacheResult: true)); } else { return(new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true)); } }
private void GetLatestDependentVersions( ImmutableDictionary <DocumentId, DocumentState> newDocumentStates, ImmutableDictionary <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) { VersionStamp oldVersion; if (oldDocument.TryGetTextVersion(out oldVersion)) { VersionStamp documentVersion; if (!this.lazyLatestDocumentVersion.TryGetValue(out documentVersion) || documentVersion == oldVersion) { recalculateDocumentVersion = true; } VersionStamp semanticVersion; if (!this.lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out 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) : this.lazyLatestDocumentVersion; dependentSemanticVersion = recalculateSemanticVersion ? new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true) : textChanged? CreateLazyLatestDocumentTopLevelChangeVersion(newDocument, newDocumentStates, newAdditionalDocumentStates) : this.lazyLatestDocumentTopLevelChangeVersion; }
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)); }
public ProjectState UpdateAdditionalDocument(TextDocumentState newDocument, bool textChanged, bool recalculateDependentVersions) { Contract.Requires(this.ContainsAdditionalDocument(newDocument.Id)); var oldDocument = this.GetAdditionalDocumentState(newDocument.Id); if (oldDocument == newDocument) { return this; } var newDocumentStates = this.AdditionalDocumentStates.SetItem(newDocument.Id, newDocument); AsyncLazy<VersionStamp> dependentDocumentVersion; AsyncLazy<VersionStamp> dependentSemanticVersion; GetLatestDependentVersions( _documentStates, newDocumentStates, oldDocument, newDocument, recalculateDependentVersions, textChanged, out dependentDocumentVersion, out dependentSemanticVersion); return this.With( additionalDocumentStates: newDocumentStates, latestDocumentVersion: dependentDocumentVersion, latestDocumentTopLevelChangeVersion: dependentSemanticVersion); }
internal ProjectState(ProjectInfo projectInfo, HostLanguageServices languageServices, SolutionServices solutionServices) { Contract.ThrowIfNull(projectInfo); Contract.ThrowIfNull(languageServices); Contract.ThrowIfNull(solutionServices); this.languageServices = languageServices; this.solutionServices = solutionServices; this.projectInfo = FixProjectInfo(projectInfo); this.documentIds = this.projectInfo.Documents.Select(d => d.Id).ToImmutableArray(); this.additionalDocumentIds = this.ProjectInfo.AdditionalDocuments.Select(d => d.Id).ToImmutableArray(); var docStates = ImmutableDictionary.CreateRange <DocumentId, DocumentState>( this.projectInfo.Documents.Select(d => new KeyValuePair <DocumentId, DocumentState>(d.Id, CreateDocument(this.ProjectInfo, d, languageServices, solutionServices)))); this.documentStates = docStates; var additionalDocStates = ImmutableDictionary.CreateRange <DocumentId, TextDocumentState>( this.projectInfo.AdditionalDocuments.Select(d => new KeyValuePair <DocumentId, TextDocumentState>(d.Id, TextDocumentState.Create(d, solutionServices)))); this.additionalDocumentStates = additionalDocStates; this.lazyLatestDocumentVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentVersionAsync(docStates, additionalDocStates, c), cacheResult: true); this.lazyLatestDocumentTopLevelChangeVersion = new AsyncLazy <VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(docStates, additionalDocStates, c), cacheResult: true); }
public bool HasInfoChanged(TextDocumentState oldState) => oldState.Attributes != Attributes;
public bool HasInfoChanged(TextDocumentState oldState) { return(oldState.Attributes != Attributes); }
private AsyncLazy<VersionStamp> CreateLazyLatestDocumentTopLevelChangeVersion( TextDocumentState newDocument, ImmutableDictionary<DocumentId, DocumentState> newDocumentStates, ImmutableDictionary<DocumentId, TextDocumentState> newAdditionalDocumentStates) { VersionStamp oldVersion; if (_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out oldVersion)) { return new AsyncLazy<VersionStamp>(c => ComputeTopLevelChangeTextVersionAsync(oldVersion, newDocument, c), cacheResult: true); } else { return new AsyncLazy<VersionStamp>(c => ComputeLatestDocumentTopLevelChangeVersionAsync(newDocumentStates, newAdditionalDocumentStates, c), cacheResult: true); } }
private SolutionState WithTextDocumentState(TextDocumentState newDocument, bool textChanged = false, bool recalculateDependentVersions = false) { if (newDocument == null) { throw new ArgumentNullException(nameof(newDocument)); } CheckContainsAdditionalDocument(newDocument.Id); if (newDocument == this.GetAdditionalDocumentState(newDocument.Id)) { // old and new documents are the same instance return this; } var oldProject = this.GetProjectState(newDocument.Id.ProjectId); var newProject = oldProject.UpdateAdditionalDocument(newDocument, textChanged, recalculateDependentVersions); if (oldProject == newProject) { // old and new projects are the same instance return this; } return this.ForkProject(newProject); }
private Solution AddAdditionalDocument(TextDocumentState state) { if (state == null) { throw new ArgumentNullException(nameof(state)); } CheckContainsProject(state.Id.ProjectId); var oldProject = this.GetProjectState(state.Id.ProjectId); var newProject = oldProject.AddAdditionalDocument(state); return this.ForkProject(newProject); }
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); }
public ProjectState AddAdditionalDocument(TextDocumentState document) { Contract.Requires(!this.AdditionalDocumentStates.ContainsKey(document.Id)); return this.With( projectInfo: this.ProjectInfo.WithVersion(this.Version.GetNewerVersion()).WithAdditionalDocuments(this.ProjectInfo.AdditionalDocuments.Concat(document.Info)), additionalDocumentIds: this.AdditionalDocumentIds.ToImmutableArray().Add(document.Id), additionalDocumentStates: this.AdditionalDocumentStates.Add(document.Id, document)); }
private void GetLatestDependentVersions( ImmutableDictionary<DocumentId, DocumentState> newDocumentStates, ImmutableDictionary<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) { VersionStamp oldVersion; if (oldDocument.TryGetTextVersion(out oldVersion)) { VersionStamp documentVersion; if (!_lazyLatestDocumentVersion.TryGetValue(out documentVersion) || documentVersion == oldVersion) { recalculateDocumentVersion = true; } VersionStamp semanticVersion; if (!_lazyLatestDocumentTopLevelChangeVersion.TryGetValue(out 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; _projectInfo = FixProjectInfo(projectInfo); _documentIds = _projectInfo.Documents.Select(d => d.Id).ToImmutableArray(); _additionalDocumentIds = _projectInfo.AdditionalDocuments.Select(d => d.Id).ToImmutableArray(); var docStates = ImmutableDictionary.CreateRange <DocumentId, DocumentState>( _projectInfo.Documents.Select(d => new KeyValuePair <DocumentId, DocumentState>(d.Id, CreateDocument(_projectInfo, d, languageServices, solutionServices)))); _documentStates = docStates; var additionalDocStates = ImmutableDictionary.CreateRange <DocumentId, TextDocumentState>( _projectInfo.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); // for now, let it re-calculate if anything changed. // TODO: optimize this so that we only re-calcuate checksums that are actually changed _lazyChecksums = new AsyncLazy <ProjectStateChecksums>(ComputeChecksumsAsync, cacheResult: true); }