/// <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;
}
/// <summary>
/// Create a new instance of a <see cref="DocumentInfo"/>.
/// </summary>
private DocumentInfo(DocumentAttributes attributes, TextLoader loader)
{
Attributes = attributes;
TextLoader = loader;
}
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);
}