/// <summary> /// Create a new instance of a <see cref="DocumentInfo"/>. /// </summary> private DocumentInfo( DocumentId id, string name, IEnumerable<string> folders, SourceCodeKind sourceCodeKind, TextLoader loader, string filePath, bool isGenerated) { if (id == null) { throw new ArgumentNullException(nameof(id)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } this.Id = id; this.Name = name; this.Folders = folders.ToImmutableReadOnlyListOrEmpty(); this.SourceCodeKind = sourceCodeKind; this.TextLoader = loader; this.FilePath = filePath; this.IsGenerated = isGenerated; }
protected static ValueSource<TextAndVersion> CreateRecoverableText(TextLoader loader, DocumentId documentId, SolutionServices services) { return new RecoverableTextAndVersion( new AsyncLazy<TextAndVersion>(c => LoadTextAsync(loader, documentId, services, c), cacheResult: false), services.TemporaryStorage, services.TextCache); }
public StandardTextDocument( DocumentProvider documentProvider, IVisualStudioHostProject project, DocumentKey documentKey, IReadOnlyList<string> folderNames, SourceCodeKind sourceCodeKind, ITextUndoHistoryRegistry textUndoHistoryRegistry, IVsFileChangeEx fileChangeService, ITextBuffer openTextBuffer, DocumentId id, EventHandler updatedOnDiskHandler, EventHandler<bool> openedHandler, EventHandler<bool> closingHandler) { Contract.ThrowIfNull(documentProvider); this.Project = project; this.Id = id ?? DocumentId.CreateNewId(project.Id, documentKey.Moniker); this.Folders = folderNames; _documentProvider = documentProvider; this.Key = documentKey; this.SourceCodeKind = sourceCodeKind; _itemMoniker = documentKey.Moniker; _textUndoHistoryRegistry = textUndoHistoryRegistry; _fileChangeTracker = new FileChangeTracker(fileChangeService, this.FilePath); _fileChangeTracker.UpdatedOnDisk += OnUpdatedOnDisk; _openTextBuffer = openTextBuffer; _snapshotTracker = new ReiteratedVersionSnapshotTracker(openTextBuffer); // The project system does not tell us the CodePage specified in the proj file, so // we use null to auto-detect. _doNotAccessDirectlyLoader = new FileTextLoader(documentKey.Moniker, defaultEncoding: null); // If we aren't already open in the editor, then we should create a file change notification if (openTextBuffer == null) { _fileChangeTracker.StartFileChangeListeningAsync(); } if (updatedOnDiskHandler != null) { UpdatedOnDisk += updatedOnDiskHandler; } if (openedHandler != null) { Opened += openedHandler; } if (closingHandler != null) { Closing += closingHandler; } }
public static DocumentInfo Create( DocumentId id, string name, IEnumerable<string> folders = null, SourceCodeKind sourceCodeKind = SourceCodeKind.Regular, TextLoader loader = null, string filePath = null, bool isGenerated = false) { return new DocumentInfo(id, name, folders, sourceCodeKind, loader, filePath, isGenerated); }
internal DocumentState UpdateText(TextLoader loader, SourceText textOpt, PreservationMode mode) { if (loader == null) { throw new ArgumentNullException(nameof(loader)); } var newTextSource = mode == PreservationMode.PreserveIdentity ? CreateStrongText(loader, this.Id, this.solutionServices, reportInvalidDataException: true) : CreateRecoverableText(loader, this.Id, this.solutionServices, reportInvalidDataException: true); // Only create the ValueSource for creating the SyntaxTree if this is a Document that // supports SyntaxTrees. There's no point in creating the async lazy and holding onto // this data otherwise. var newTreeSource = !this.SupportsSyntaxTree ? ValueSource<TreeAndVersion>.Empty : CreateLazyFullyParsedTree( newTextSource, this.Id.ProjectId, GetSyntaxTreeFilePath(this.info), _options, _languageServices, this.solutionServices, mode); return new DocumentState( this.LanguageServices, this.solutionServices, this.info, _options, sourceTextOpt: textOpt, textSource: newTextSource, treeSource: newTreeSource); }
/// <summary> /// Create a new instance of a <see cref="DocumentInfo"/>. /// </summary> private DocumentInfo(DocumentAttributes attributes, TextLoader loader) { Attributes = attributes; TextLoader = loader; }
/// <summary> /// Create a new instance of a <see cref="DocumentInfo"/>. /// </summary> internal DocumentInfo(DocumentAttributes attributes, TextLoader loader, IDocumentServiceProvider documentServiceProvider) { Attributes = attributes; TextLoader = loader; DocumentServiceProvider = documentServiceProvider; }
protected static ValueSource <TextAndVersion> CreateStrongText(TextLoader loader, DocumentId documentId, SolutionServices services, bool reportInvalidDataException) { return(new AsyncLazy <TextAndVersion>(c => LoadTextAsync(loader, documentId, services, reportInvalidDataException, c), cacheResult: true)); }
private static async Task<TextAndVersion> LoadTextAsync(TextLoader loader, DocumentId documentId, SolutionServices services, CancellationToken cancellationToken) { try { using (ExceptionHelpers.SuppressFailFast()) { var result = await loader.LoadTextAndVersionAsync(services.Workspace, documentId, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); return result; } } catch (OperationCanceledException) { // if load text is failed due to a cancellation, make sure we propagate it out to the caller throw; } catch (IOException e) { services.Workspace.OnWorkspaceFailed(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, e.Message, documentId)); return TextAndVersion.Create(SourceText.From(string.Empty, Encoding.UTF8), VersionStamp.Default, documentId.GetDebuggerDisplay()); } }
private static ValueSource<TextAndVersion> CreateStrongText(TextLoader loader, DocumentId documentId, SolutionServices services) { return new AsyncLazy<TextAndVersion>(c => LoadTextAsync(loader, documentId, services, c), cacheResult: true); }
internal Solution WithDocumentTextLoader(DocumentId documentId, TextLoader loader, SourceText textOpt, PreservationMode mode) { var newState = _state.WithDocumentTextLoader(documentId, loader, textOpt, mode); if (newState == _state) { return this; } return new Solution(newState); }
/// <summary> /// Creates a new solution instance with the additional document specified updated to have the text /// supplied by the text loader. /// </summary> public Solution WithAdditionalDocumentTextLoader(DocumentId documentId, TextLoader loader, PreservationMode mode) { var newState = _state.WithAdditionalDocumentTextLoader(documentId, loader, mode); if (newState == _state) { return this; } return new Solution(newState); }
public DocumentInfo WithTextLoader(TextLoader loader) { return(this.With(loader: loader)); }
public new AnalyzerConfigDocumentState UpdateText(TextLoader loader, PreservationMode mode) { return((AnalyzerConfigDocumentState)base.UpdateText(loader, mode)); }
private static ValueSource <TextAndVersion> CreateStrongText(TextLoader loader, DocumentId documentId, SolutionServices services) { return(new AsyncLazy <TextAndVersion>(c => LoadTextAsync(loader, documentId, services, c), cacheResult: true)); }
/// <summary> /// Create a new instance of a <see cref="DocumentInfo"/>. /// </summary> internal DocumentInfo(DocumentAttributes attributes, TextLoader loader) { Attributes = attributes; TextLoader = loader; }
public new AdditionalDocumentState UpdateText(TextLoader loader, PreservationMode mode) => (AdditionalDocumentState)base.UpdateText(loader, mode);
/// <summary> /// Creates a new solution instance with the document specified updated to have the text /// supplied by the text loader. /// </summary> public Solution WithDocumentTextLoader(DocumentId documentId, TextLoader loader, PreservationMode mode) { return(WithDocumentTextLoader(documentId, loader, textOpt: null, mode: mode)); }
public void OnAdditionalDocumentClosed(DocumentId documentId, ITextBuffer textBuffer, TextLoader loader) { }
protected static ValueSource<TextAndVersion> CreateRecoverableText(TextLoader loader, DocumentId documentId, SolutionServices services, bool reportInvalidDataException) { return new RecoverableTextAndVersion( new AsyncLazy<TextAndVersion>( asynchronousComputeFunction: c => LoadTextAsync(loader, documentId, services, reportInvalidDataException, c), synchronousComputeFunction: c => LoadTextSynchronously(loader, documentId, services, reportInvalidDataException, c), cacheResult: false), services.TemporaryStorage); }
public void OnDocumentClosed(DocumentId documentId, ITextBuffer textBuffer, TextLoader loader, bool updateActiveContext) { }
public DocumentState UpdateText(TextLoader loader, PreservationMode mode) { if (loader == null) { throw new ArgumentNullException("loader"); } var newTextSource = (mode == PreservationMode.PreserveIdentity) ? CreateStrongText(loader, this.Id, this.solutionServices) : CreateRecoverableText(loader, this.Id, this.solutionServices); var newTreeSource = CreateLazyFullyParsedTree( newTextSource, GetSyntaxTreeFilePath(this.info), this.options, this.languageServices, mode); return new DocumentState( this.LanguageServices, this.solutionServices, this.info, this.options, textSource: newTextSource, treeSource: newTreeSource); }
public TextDocumentState UpdateText(TextLoader loader, PreservationMode mode) { if (loader == null) { throw new ArgumentNullException(nameof(loader)); } // don't blow up on non-text documents. var newTextSource = (mode == PreservationMode.PreserveIdentity) ? CreateStrongText(loader, this.Id, this.solutionServices, reportInvalidDataException: false) : CreateRecoverableText(loader, this.Id, this.solutionServices, reportInvalidDataException: false); return new TextDocumentState( this.solutionServices, this.info, textSource: newTextSource); }
public StandardTextDocument( DocumentProvider documentProvider, IVisualStudioHostProject project, DocumentKey documentKey, uint itemId, SourceCodeKind sourceCodeKind, ITextBufferFactoryService textBufferFactoryService, ITextUndoHistoryRegistry textUndoHistoryRegistry, IVsFileChangeEx fileChangeService, ITextBuffer openTextBuffer, DocumentId id) { Contract.ThrowIfNull(documentProvider); Contract.ThrowIfNull(textBufferFactoryService); this.Project = project; this.Id = id ?? DocumentId.CreateNewId(project.Id, documentKey.Moniker); this.Folders = project.GetFolderNames(itemId); // TODO: // this one doesn't work for asynchronous project load situation where shared projects is loaded after one uses shared file. // we need to figure out what to do on those case. but this works for project k case. // opened an issue to track this issue - https://github.com/dotnet/roslyn/issues/1859 this.SharedHierarchy = project.Hierarchy == null ? null : LinkedFileUtilities.GetSharedHierarchyForItem(project.Hierarchy, itemId); _documentProvider = documentProvider; this.Key = documentKey; this.SourceCodeKind = sourceCodeKind; _itemMoniker = documentKey.Moniker; _textBufferFactoryService = textBufferFactoryService; _textUndoHistoryRegistry = textUndoHistoryRegistry; _fileChangeTracker = new FileChangeTracker(fileChangeService, this.FilePath); _fileChangeTracker.UpdatedOnDisk += OnUpdatedOnDisk; _openTextBuffer = openTextBuffer; _snapshotTracker = new ReiteratedVersionSnapshotTracker(openTextBuffer); // The project system does not tell us the CodePage specified in the proj file, so // we use null to auto-detect. _doNotAccessDirectlyLoader = new FileTextLoader(documentKey.Moniker, defaultEncoding: null); // If we aren't already open in the editor, then we should create a file change notification if (openTextBuffer == null) { _fileChangeTracker.StartFileChangeListeningAsync(); } }
protected static async Task<TextAndVersion> LoadTextAsync(TextLoader loader, DocumentId documentId, SolutionServices services, bool reportInvalidDataException, CancellationToken cancellationToken) { int retries = 0; while (true) { try { using (ExceptionHelpers.SuppressFailFast()) { var result = await loader.LoadTextAndVersionAsync(services.Workspace, documentId, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); return result; } } catch (OperationCanceledException) { // if load text is failed due to a cancellation, make sure we propagate it out to the caller throw; } catch (IOException e) { if (++retries > MaxRetries) { services.Workspace.OnWorkspaceFailed(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, e.Message, documentId)); return TextAndVersion.Create(SourceText.From(string.Empty, Encoding.UTF8), VersionStamp.Default, documentId.GetDebuggerDisplay()); } // fall out to try again } catch (InvalidDataException e) { // TODO: Adjust this behavior in the future if we add support for non-text additional files if (reportInvalidDataException) { services.Workspace.OnWorkspaceFailed(new DocumentDiagnostic(WorkspaceDiagnosticKind.Failure, e.Message, documentId)); } return TextAndVersion.Create(SourceText.From(string.Empty, Encoding.UTF8), VersionStamp.Default, documentId.GetDebuggerDisplay()); } // try again after a delay await Task.Delay(RetryDelay).ConfigureAwait(false); } }
public DocumentInfo WithTextLoader(TextLoader loader) { return this.With(loader: loader); }
/// <summary> /// Creates a new solution instance with the document specified updated to have the text /// supplied by the text loader. /// </summary> public Solution WithDocumentTextLoader(DocumentId documentId, TextLoader loader, PreservationMode mode) { return WithDocumentTextLoader(documentId, loader, textOpt: null, mode: mode); }
public TextDocumentState UpdateText(TextLoader loader, PreservationMode mode) { if (loader == null) { throw new ArgumentNullException("loader"); } var newTextSource = (mode == PreservationMode.PreserveIdentity) ? CreateStrongText(loader, this.Id, this.solutionServices) : CreateRecoverableText(loader, this.Id, this.solutionServices); return new TextDocumentState( this.solutionServices, this.info, textSource: newTextSource); }
protected static ValueSource <TextAndVersion> CreateRecoverableText(TextLoader loader, DocumentId documentId, SolutionServices services, bool reportInvalidDataException) { return(new RecoverableTextAndVersion( new AsyncLazy <TextAndVersion>(c => LoadTextAsync(loader, documentId, services, reportInvalidDataException, c), cacheResult: false), services.TemporaryStorage)); }
protected static ValueSource<TextAndVersion> CreateStrongText(TextLoader loader, DocumentId documentId, SolutionServices services, bool reportInvalidDataException) { return new AsyncLazy<TextAndVersion>(c => LoadTextAsync(loader, documentId, services, reportInvalidDataException, c), cacheResult: true); }
public new DocumentState UpdateText(TextLoader loader, PreservationMode mode) { return(UpdateText(loader, textOpt: null, mode: mode)); }
/// <summary> /// Creates a new solution instance with the project updated to include a new document with /// the arguments specified. /// </summary> public Solution AddDocument(DocumentId documentId, string name, TextLoader loader, IEnumerable<string> folders = null) { if (documentId == null) { throw new ArgumentNullException(nameof(documentId)); } CheckContainsProject(documentId.ProjectId); CheckNotContainsDocument(documentId); if (name == null) { throw new ArgumentNullException(nameof(name)); } if (loader == null) { throw new ArgumentNullException(nameof(loader)); } var project = this.GetProjectState(documentId.ProjectId); var info = DocumentInfo.Create( documentId, name: name, folders: folders, sourceCodeKind: GetSourceCodeKind(project), loader: loader); return this.AddDocument(info); }
public new DocumentState UpdateText(TextLoader loader, PreservationMode mode) { return UpdateText(loader, textOpt: null, mode: mode); }
/// <summary> /// Creates a new solution instance with the additional document specified updated to have the text /// supplied by the text loader. /// </summary> public SolutionState WithAdditionalDocumentTextLoader(DocumentId documentId, TextLoader loader, PreservationMode mode) { CheckContainsAdditionalDocument(documentId); var oldDocument = this.GetAdditionalDocumentState(documentId); // assumes that text has changed. user could have closed a doc without saving and we are loading text from closed file with // old content. also this should make sure we don't re-use latest doc version with data associated with opened document. return this.WithTextDocumentState(oldDocument.UpdateText(loader, mode), textChanged: true, recalculateDependentVersions: true); }
public new DocumentState UpdateText(TextLoader loader, PreservationMode mode) { if (loader == null) { throw new ArgumentNullException(nameof(loader)); } var newTextSource = (mode == PreservationMode.PreserveIdentity) ? CreateStrongText(loader, this.Id, this.solutionServices, reportInvalidDataException: true) : CreateRecoverableText(loader, this.Id, this.solutionServices, reportInvalidDataException: true); var newTreeSource = CreateLazyFullyParsedTree( newTextSource, this.Id.ProjectId, GetSyntaxTreeFilePath(this.info), _options, _languageServices, this.solutionServices, mode); return new DocumentState( this.LanguageServices, this.solutionServices, this.info, _options, textSource: newTextSource, treeSource: newTreeSource); }