public static bool CanReusePersistedTextVersion(this Document document, VersionStamp textVersion, VersionStamp persistedVersion) { var canReuse = VersionStamp.CanReusePersistedVersion(textVersion, persistedVersion); PersistedVersionStampLogger.LogPersistedTextVersionUsage(canReuse); return(canReuse); }
protected static async Task <T> LoadAsync <T>( Document document, string persistenceName, string formatVersion, Func <ObjectReader, VersionStamp, T> readFrom, CancellationToken cancellationToken) where T : AbstractPersistableState { var persistentStorageService = WorkspaceService.GetService <IPersistentStorageService>(document.Project.Solution.Workspace); var version = await document.GetSyntaxVersionAsync(cancellationToken).ConfigureAwait(false); // attempt to load from persisted state using (var storage = persistentStorageService.GetStorage(document.Project.Solution)) using (var stream = await storage.ReadStreamAsync(document, persistenceName, cancellationToken).ConfigureAwait(false)) { if (stream == null) { return(null); } using (var reader = new ObjectReader(stream)) { VersionStamp persistVersion; if (TryReadVersion(reader, formatVersion, out persistVersion) && VersionStamp.CanReusePersistedVersion(version, persistVersion)) { return(readFrom(reader, version)); } } } return(null); }
public static bool CanReusePersistedDependentProjectVersion(this Project project, VersionStamp dependentProjectVersion, VersionStamp persistedVersion) { var canReuse = VersionStamp.CanReusePersistedVersion(dependentProjectVersion, persistedVersion); PersistedVersionStampLogger.LogPersistedDependentProjectVersionUsage(canReuse); return(canReuse); }
private static bool CanReusePersistedSemanticVersionInternal( Project project, VersionStamp projectVersion, VersionStamp semanticVersion, VersionStamp persistedVersion, Func <ISemanticVersionTrackingService, Project, VersionStamp, VersionStamp> versionGetter) { var canReuse = VersionStamp.CanReusePersistedVersion(semanticVersion, persistedVersion); if (canReuse) { return(true); } var service = project.Solution.Workspace.Services.GetService <ISemanticVersionTrackingService>(); if (service == null) { return(canReuse); } var persistedProjectVersion = versionGetter(service, project, persistedVersion); return(VersionStamp.CanReusePersistedVersion(projectVersion, persistedProjectVersion)); }
/// <summary> /// this is for a metadata reference in a solution /// </summary> private static async Task <SymbolTreeInfo> LoadOrCreateAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken) { // if assembly is not from a file, just create one on the fly if (filePath == null || !File.Exists(filePath) || !FilePathUtilities.PartOfFrameworkOrReferencePaths(filePath)) { return(Create(VersionStamp.Default, assembly, cancellationToken)); } // if solution is not from a disk, just create one. if (solution.FilePath == null || !File.Exists(solution.FilePath)) { return(Create(VersionStamp.Default, assembly, cancellationToken)); } // okay, see whether we can get one from persistence service. var relativePath = FilePathUtilities.GetRelativePath(solution.FilePath, filePath); var version = VersionStamp.Create(File.GetLastWriteTimeUtc(filePath)); var persistentStorageService = solution.Workspace.Services.GetService <IPersistentStorageService>(); // attempt to load from persisted state. metadata reference is solution wise information SymbolTreeInfo info; using (var storage = persistentStorageService.GetStorage(solution)) { var key = PrefixMetadataSymbolTreeInfo + relativePath; using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false)) { if (stream != null) { using (var reader = new ObjectReader(stream)) { info = ReadFrom(reader); if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version)) { return(info); } } } } cancellationToken.ThrowIfCancellationRequested(); // compute it if we couldn't load it from cache info = Create(version, assembly, cancellationToken); if (info != null) { using (var stream = SerializableBytes.CreateWritableStream()) using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken)) { info.WriteTo(writer); stream.Position = 0; await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false); } } } return(info); }
public static bool CanReusePersistedSyntaxTreeVersion(this Document document, VersionStamp syntaxVersion, VersionStamp persistedVersion) { var canReuse = VersionStamp.CanReusePersistedVersion(syntaxVersion, persistedVersion); PersistedVersionStampLogger.LogPersistedSyntaxTreeVersionUsage(canReuse); return(canReuse); }
private static bool CheckSemanticVersions(Project project, AnalysisData existingData, VersionArgument versions) { if (existingData == null) { return(false); } return(VersionStamp.CanReusePersistedVersion(versions.TextVersion, existingData.TextVersion) && project.CanReusePersistedDependentSemanticVersion(versions.ProjectVersion, versions.DataVersion, existingData.DataVersion)); }
/// <summary> /// this is for a project in a solution /// </summary> private static async Task <ValueTuple <bool, SymbolTreeInfo> > LoadOrCreateAsync(Project project, CancellationToken cancellationToken) { if (await project.IsForkedProjectWithSemanticChangesAsync(cancellationToken).ConfigureAwait(false)) { return(ValueTuple.Create(false, await CreateAsync(project, cancellationToken).ConfigureAwait(false))); } var persistentStorageService = WorkspaceService.GetService <IPersistentStorageService>(project.Solution.Workspace); var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false); // attempt to load from persisted state SymbolTreeInfo info; var succeeded = false; using (var storage = persistentStorageService.GetStorage(project.Solution)) { using (var stream = await storage.ReadStreamAsync(project, ProjectSymbolTreeInfoPersistenceName, cancellationToken).ConfigureAwait(false)) { if (stream != null) { using (var reader = new ObjectReader(stream)) { info = ReadFrom(reader); if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version)) { return(ValueTuple.Create(true, info)); } } } } cancellationToken.ThrowIfCancellationRequested(); // compute it if we couldn't load it from cache info = await CreateAsync(project, cancellationToken).ConfigureAwait(false); if (info != null) { using (var stream = SerializableBytes.CreateWritableStream()) using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken)) { info.WriteTo(writer); stream.Position = 0; succeeded = await storage.WriteStreamAsync(project, ProjectSymbolTreeInfoPersistenceName, stream, cancellationToken).ConfigureAwait(false); } } } return(ValueTuple.Create(succeeded, info)); }
public VersionStamp GetInitialDependentProjectVersionFromDependentSemanticVersion(Project project, VersionStamp dependentSemanticVersion) { if (!TryGetInitialVersions(s_initialDependentSemanticVersions, project, DependentSemanticVersion, out var versions)) { return(VersionStamp.Default); } if (!VersionStamp.CanReusePersistedVersion(dependentSemanticVersion, versions.SemanticVersion)) { return(VersionStamp.Default); } return(versions.ProjectVersion); }
private static bool CanReusePersistedSemanticVersionInternal( Project project, VersionStamp projectVersion, VersionStamp semanticVersion, VersionStamp persistedVersion, Func <ISemanticVersionTrackingService, Project, VersionStamp, VersionStamp> versionGetter) { // * NOTE * // Disabled semantic version tracking // we need better version for it to reliably work. // // see tracking issue here : https://github.com/dotnet/roslyn/issues/2311 return(VersionStamp.CanReusePersistedVersion(semanticVersion, persistedVersion)); }
public VersionStamp GetInitialProjectVersionFromSemanticVersion(Project project, VersionStamp semanticVersion) { Versions versions; if (!TryGetInitialVersions(s_initialSemanticVersions, project, SemanticVersion, out versions)) { return(VersionStamp.Default); } if (!VersionStamp.CanReusePersistedVersion(semanticVersion, versions.SemanticVersion)) { return(VersionStamp.Default); } return(versions.ProjectVersion); }
public static async Task <bool> IdentifierSetPrecalculatedAsync(Document document, CancellationToken cancellationToken) { var version = await document.GetSyntaxVersionAsync(cancellationToken).ConfigureAwait(false); var persistentStorageService = WorkspaceService.GetService <IPersistentStorageService>(document.Project.Solution.Workspace); using (var storage = persistentStorageService.GetStorage(document.Project.Solution)) { var esentStorage = storage as ISyntaxTreeInfoPersistentStorage; if (esentStorage == null) { // basically, we don't support it. return true so that we don't try to precalcuate it return(true); } var persistedVersion = esentStorage.GetIdentifierSetVersion(document); return(VersionStamp.CanReusePersistedVersion(version, persistedVersion)); } }
internal static async Task <ImmutableDictionary <string, DesignerAttributeDocumentData> > TryAnalyzeProjectInCurrentProcessAsync( Project project, CancellationToken cancellationToken) { var projectVersion = await project.GetDependentVersionAsync(cancellationToken).ConfigureAwait(false); var semanticVersion = await project.GetDependentSemanticVersionAsync(cancellationToken).ConfigureAwait(false); // Get whatever data we've current persisted. var designerAttributeData = await DesignerAttributeProjectData.ReadAsync( project, cancellationToken).ConfigureAwait(false); // If we have no persisted data, or the persisted data is for a previous version of // the project, then compute the results for the current project snapshot. if (designerAttributeData == null || !VersionStamp.CanReusePersistedVersion(semanticVersion, designerAttributeData.SemanticVersion)) { designerAttributeData = await ComputeAndPersistDesignerAttributeProjectDataAsync( project, semanticVersion, cancellationToken).ConfigureAwait(false); } return(designerAttributeData.PathToDocumentData); }
protected static async Task <bool> PrecalculatedAsync(Document document, string persistenceName, string formatVersion, CancellationToken cancellationToken) { Contract.Requires(document.IsFromPrimaryBranch()); var persistentStorageService = WorkspaceService.GetService <IPersistentStorageService>(document.Project.Solution.Workspace); var version = await document.GetSyntaxVersionAsync(cancellationToken).ConfigureAwait(false); // check whether we already have info for this document using (var storage = persistentStorageService.GetStorage(document.Project.Solution)) using (var stream = await storage.ReadStreamAsync(document, persistenceName, cancellationToken).ConfigureAwait(false)) { if (stream != null) { using (var reader = new ObjectReader(stream)) { VersionStamp persistVersion; return(TryReadVersion(reader, formatVersion, out persistVersion) && VersionStamp.CanReusePersistedVersion(version, persistVersion)); } } } return(false); }
/// <summary> /// Generalized function for loading/creating/persisting data. Used as the common core /// code for serialization of SymbolTreeInfos and SpellCheckers. /// </summary> private static async Task <T> LoadOrCreateAsync <T>( Solution solution, string filePath, bool loadOnly, Func <VersionStamp, T> create, string keySuffix, Func <T, VersionStamp> getVersion, Func <ObjectReader, T> readObject, Action <ObjectWriter, T> writeObject, CancellationToken cancellationToken) where T : class { // See if we can even use serialization. If not, we'll just have to make the value // from scratch. string prefix; VersionStamp version; if (ShouldCreateFromScratch(solution, filePath, out prefix, out version, cancellationToken)) { return(loadOnly ? null : create(VersionStamp.Default)); } // Ok, we can use persistence. First try to load from the persistence service. var persistentStorageService = solution.Workspace.Services.GetService <IPersistentStorageService>(); T result; using (var storage = persistentStorageService.GetStorage(solution)) { // Get the unique key to identify our data. var key = PrefixMetadataSymbolTreeInfo + prefix + keySuffix; using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false)) { if (stream != null) { using (var reader = new ObjectReader(stream)) { // We have some previously persisted data. Attempt to read it back. // If we're able to, and the version of the persisted data matches // our version, then we can reuse this instance. result = readObject(reader); if (result != null && VersionStamp.CanReusePersistedVersion(version, getVersion(result))) { return(result); } } } } cancellationToken.ThrowIfCancellationRequested(); // Couldn't read from the persistence service. If we've been asked to only load // data and not create new instances in their absense, then there's nothing left // to do at this point. if (loadOnly) { return(null); } // Now, try to create a new instance and write it to the persistence service. result = create(version); if (result != null) { using (var stream = SerializableBytes.CreateWritableStream()) using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken)) { writeObject(writer, result); stream.Position = 0; await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false); } } } return(result); }
/// <summary> /// this is for a metadata reference in a solution /// </summary> private static async Task <SymbolTreeInfo> LoadOrCreateAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken) { var service = solution.Workspace.Services.GetService <IAssemblySerializationInfoService>(); if (service == null) { return(Create(VersionStamp.Default, assembly, cancellationToken)); } // check whether the assembly that belong to a solution is something we can serialize if (!service.Serializable(solution, filePath)) { return(Create(VersionStamp.Default, assembly, cancellationToken)); } string prefix; VersionStamp version; if (!service.TryGetSerializationPrefixAndVersion(solution, filePath, out prefix, out version)) { return(Create(VersionStamp.Default, assembly, cancellationToken)); } var persistentStorageService = solution.Workspace.Services.GetService <IPersistentStorageService>(); // okay, see whether we can get one from persistence service. // attempt to load from persisted state. metadata reference is solution wise information SymbolTreeInfo info; using (var storage = persistentStorageService.GetStorage(solution)) { var key = PrefixMetadataSymbolTreeInfo + prefix; using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false)) { if (stream != null) { using (var reader = new ObjectReader(stream)) { info = ReadFrom(reader); if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version)) { return(info); } } } } cancellationToken.ThrowIfCancellationRequested(); // compute it if we couldn't load it from cache info = Create(version, assembly, cancellationToken); if (info != null) { using (var stream = SerializableBytes.CreateWritableStream()) using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken)) { info.WriteTo(writer); stream.Position = 0; await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false); } } } return(info); }