public void RemoveProject(AbstractProject project)
{
_typeScriptProjects.Remove(project.Id);
project.VisualStudioProject.RemoveFromWorkspace();
project.VisualStudioProject = null;
}
internal bool ContainsProject(AbstractProject project)
{
lock (_gate)
{
return(_projectMap.ContainsKey(project.Id));
}
}
/// <summary>
/// Creates a <see cref="StandardTextDocument"/>.
/// <para>Note: getFolderNames maps from a VSITEMID to the folders this document should be contained in.</para>
/// </summary>
public StandardTextDocument(
DocumentProvider documentProvider,
AbstractProject project,
DocumentKey documentKey,
Func <uint, IReadOnlyList <string> > getFolderNames,
SourceCodeKind sourceCodeKind,
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);
_itemMoniker = documentKey.Moniker;
var itemid = this.GetItemId();
this.Folders = itemid == (uint)VSConstants.VSITEMID.Nil
? SpecializedCollections.EmptyReadOnlyList <string>()
: getFolderNames(itemid);
_documentProvider = documentProvider;
this.Key = documentKey;
this.SourceCodeKind = sourceCodeKind;
_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;
}
}
private AbstractProject TryFindExistingProjectForProjectReference(string projectReferencePath, ImmutableArray <MetadataReference> metadataReferences)
{
// NOTE: ImmutableProjects might contain projects for other languages like
// Xaml, or Typescript where the project file ends up being identical.
AbstractProject candidate = null;
foreach (var existingProject in ImmutableProjects)
{
if (existingProject.Language != LanguageNames.CSharp && existingProject.Language != LanguageNames.VisualBasic)
{
continue;
}
if (!StringComparer.OrdinalIgnoreCase.Equals(existingProject.ProjectFilePath, projectReferencePath))
{
continue;
}
// There might be multiple projects that have the same project file path and language in the case of
// cross-targeted .NET Core project. To support that, we'll try to find the one with the output path
// that matches one of the metadata references we're trying to add. If we don't find any, then we'll
// settle one with a matching project file path.
candidate = candidate ?? existingProject;
if (metadataReferences.Contains(mr => StringComparer.OrdinalIgnoreCase.Equals(GetReferencePath(mr), existingProject.BinOutputPath)))
{
return(existingProject);
}
}
return(candidate);
}
public ShimDocument(AbstractProject hostProject, DocumentId id, string filePath, SourceCodeKind sourceCodeKind = SourceCodeKind.Regular)
{
Project = hostProject;
Id = id ?? DocumentId.CreateNewId(hostProject.Id, filePath);
FilePath = filePath;
SourceCodeKind = sourceCodeKind;
}
private ProjectItem AddDocumentToProjectItems(
AbstractProject hostProject,
ProjectItems projectItems,
DocumentId documentId,
string folderPath,
string documentName,
SourceCodeKind sourceCodeKind,
SourceText initialText,
string filePath,
bool isAdditionalDocument)
{
if (filePath == null)
{
var baseName = Path.GetFileNameWithoutExtension(documentName);
var extension = isAdditionalDocument ? Path.GetExtension(documentName) : GetPreferredExtension(hostProject, sourceCodeKind);
var uniqueName = projectItems.GetUniqueName(baseName, extension);
filePath = Path.Combine(folderPath, uniqueName);
}
if (initialText != null)
{
using (var writer = new StreamWriter(filePath, append: false, encoding: initialText.Encoding ?? Encoding.UTF8))
{
initialText.Write(writer);
}
}
using (var documentIdHint = DeferredState.ProjectTracker.DocumentProvider.ProvideDocumentIdHint(filePath, documentId))
{
return(projectItems.AddFromFile(filePath));
}
}
public void AddProject(AbstractProject project)
{
project.VisualStudioProject = _projectFactory.CreateAndAddToWorkspace(project.ProjectSystemName, project.Language);
project.UpdateVisualStudioProjectProperties();
_typeScriptProjects[project.Id] = project;
}
internal void GetProjectData(ProjectId projectId, out AbstractProject hostProject, out IVsHierarchy hierarchy, out EnvDTE.Project project)
{
if (!TryGetProjectData(projectId, out hostProject, out hierarchy, out project))
{
throw new ArgumentException(string.Format(ServicesVSResources.Could_not_find_project_0, projectId));
}
}
/// <summary>
/// Attempts to get single project by given output binary filePath.
/// </summary>
/// <remarks>This method may be called on a background thread.</remarks>
internal bool TryGetProjectByBinPath(string filePath, out AbstractProject project)
{
lock (_gate)
{
project = null;
if (!_projectsByBinPath.TryGetValue(filePath, out var projects))
{
// Workaround https://github.com/dotnet/roslyn/issues/20412 by checking to see if */ref/A.dll can be
// adjusted to */A.dll - only handles the default location for reference assemblies during a build.
if (!HACK_StripRefDirectoryFromPath(filePath, out string binFilePath) ||
!_projectsByBinPath.TryGetValue(binFilePath, out projects))
{
return(false);
}
}
// If for some reason we have more than one referencing project, it's ambiguous so bail
if (projects.Length == 1)
{
project = projects[0];
return(true);
}
return(false);
}
}
public DocumentKey(AbstractProject hostProject, string moniker)
{
Contract.ThrowIfNull(hostProject);
Contract.ThrowIfNull(moniker);
_hostProject = hostProject;
_moniker = moniker;
}
internal void NotifyNonDocumentOpenedForProject(AbstractProject project)
{
AssertIsForeground();
var abstractProject = (AbstractProject)project;
StartPushingToWorkspaceAndNotifyOfOpenDocuments(SpecializedCollections.SingletonEnumerable(abstractProject));
}
private bool TryGetProjectData(ProjectId projectId, out AbstractProject hostProject, out IVsHierarchy hierarchy, out EnvDTE.Project project)
{
hierarchy = null;
project = null;
return(this.TryGetHostProject(projectId, out hostProject) &&
this.TryGetHierarchy(projectId, out hierarchy) &&
hierarchy.TryGetProject(out project));
}
internal void RemoveProject(AbstractProject project)
{
// If we've already told this host about it, then we need to remove it. Otherwise, this host has no
// further work to do.
if (_pushedProjects.Remove(project))
{
this.Host.OnProjectRemoved(project.Id);
}
}
/// <summary>
/// Creates a <see cref="StandardTextDocument"/>.
/// </summary>
public StandardTextDocument(
DocumentProvider documentProvider,
AbstractProject project,
DocumentKey documentKey,
ImmutableArray <string> folderNames,
SourceCodeKind sourceCodeKind,
IVsFileChangeEx fileChangeService,
ITextBuffer openTextBuffer,
DocumentId id,
EventHandler updatedOnDiskHandler,
EventHandler <bool> openedHandler,
EventHandler <bool> closingHandler)
: base(documentProvider.ThreadingContext)
{
Contract.ThrowIfNull(documentProvider);
this.Project = project;
this.Id = id ?? DocumentId.CreateNewId(project.Id, documentKey.Moniker);
_itemMoniker = documentKey.Moniker;
this.Folders = folderNames;
_documentProvider = documentProvider;
this.Key = documentKey;
this.SourceCodeKind = sourceCodeKind;
_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 FileChangeTrackingTextLoader(_fileChangeTracker, 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 AbstractContainedLanguage(
AbstractProject project)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
this.Project = project;
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
UpdateProjectBinPath(project, project.TryGetBinOutputPath(), null);
if (project.PushingChangesToWorkspaceHosts)
{
NotifyWorkspaceHosts(host => host.OnProjectRemoved(project.Id));
}
}
public void AddProject(AbstractProject project)
{
var provider = (IProjectCodeModelProvider)project;
var fcms = provider.ProjectCodeModel.GetCachedFileCodeModelInstances();
foreach (var fcm in fcms)
{
var globalNodeKeys = fcm.Object.GetCurrentNodeKeys();
_nodeKeysMap.Add(fcm, globalNodeKeys);
}
}
public IVisualStudioHostDocument TryGetDocumentForFile(
AbstractProject hostProject,
string filePath,
SourceCodeKind sourceCodeKind,
Func <ITextBuffer, bool> canUseTextBuffer,
Func <uint, IReadOnlyList <string> > getFolderNames,
EventHandler updatedOnDiskHandler = null,
EventHandler <bool> openedHandler = null,
EventHandler <bool> closingHandler = null)
{
return(new ShimDocument(hostProject, DocumentId.CreateNewId(hostProject.Id), filePath, sourceCodeKind));
}
internal void UpdateProjectBinPath(AbstractProject project, string oldBinPathOpt, string newBinPathOpt)
{
if (oldBinPathOpt != null)
{
UpdateReferencesForBinPathChange(oldBinPathOpt, () => _projectsByBinPath.MultiRemove(oldBinPathOpt, project));
}
if (newBinPathOpt != null)
{
UpdateReferencesForBinPathChange(newBinPathOpt, () => _projectsByBinPath.MultiAdd(newBinPathOpt, project));
}
}
public void AddProject(AbstractProject project)
{
var provider = (IProjectCodeModelProvider)project;
IEnumerable<ComHandle<EnvDTE80.FileCodeModel2, FileCodeModel>> fcms = provider.ProjectCodeModel.GetFileCodeModelInstances();
foreach (var fcm in fcms)
{
var globalNodeKeys = fcm.Object.GetCurrentNodeKeys();
_nodeKeysMap.Add(fcm, globalNodeKeys);
}
}
internal void AddProjectByBinPath(string filePath, AbstractProject project)
{
lock (_gate)
{
if (!_projectsByBinPath.TryGetValue(filePath, out var projects))
{
projects = ImmutableArray <AbstractProject> .Empty;
}
_projectsByBinPath[filePath] = projects.Add(project);
}
}
public VsReadOnlyDocumentTracker(IEditAndContinueWorkspaceService encService, IVsEditorAdaptersFactoryService adapters, AbstractProject vsProject)
: base(assertIsForeground: true)
{
Debug.Assert(encService.DebuggingSession != null);
_encService = encService;
_adapters = adapters;
_workspace = encService.DebuggingSession.InitialSolution.Workspace;
_vsProject = vsProject;
_workspace.DocumentOpened += OnDocumentOpened;
UpdateWorkspaceDocuments();
}
public void RemoveProject(AbstractProject project)
{
_projects.Remove(project.Id);
if (project.ExplicitId != null)
{
Workspace.OnProjectRemoved(project.ExplicitId);
}
else
{
project.VisualStudioProject.RemoveFromWorkspace();
project.VisualStudioProject = null;
}
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
UpdateProjectBinPath(project, project.TryGetBinOutputPath(), null);
using (Dispatcher.CurrentDispatcher.DisableProcessing())
{
foreach (var hostState in _workspaceHosts)
{
hostState.RemoveProject(project);
}
}
}
/// <remarks>
/// <para>The optional project is used to obtain an <see cref="IVsProject"/> 1nstance. When this instance is
/// provided, Visual Studio will use <see cref="IVsProject.IsDocumentInProject"/> to attempt to locate the
/// specified file within a project. If no project is specified, Visual Studio falls back to using
/// <see cref="IVsUIShellOpenDocument4.IsDocumentInAProject2"/>, which performs a much slower query of all
/// projects in the solution.</para>
/// </remarks>
public InvisibleEditor(IServiceProvider serviceProvider, string filePath, AbstractProject projectOpt, bool needsSave, bool needsUndoDisabled)
{
_serviceProvider = serviceProvider;
_filePath = filePath;
_needsSave = needsSave;
var invisibleEditorManager = (IIntPtrReturningVsInvisibleEditorManager)serviceProvider.GetService(typeof(SVsInvisibleEditorManager));
var vsProject = TryGetProjectOfHierarchy(projectOpt?.Hierarchy);
var invisibleEditorPtr = IntPtr.Zero;
Marshal.ThrowExceptionForHR(invisibleEditorManager.RegisterInvisibleEditor(filePath, vsProject, 0, null, out invisibleEditorPtr));
try
{
_invisibleEditor = (IVsInvisibleEditor)Marshal.GetUniqueObjectForIUnknown(invisibleEditorPtr);
var docDataPtr = IntPtr.Zero;
Marshal.ThrowExceptionForHR(_invisibleEditor.GetDocData(fEnsureWritable: needsSave ? 1 : 0, riid: typeof(IVsTextLines).GUID, ppDocData: out docDataPtr));
try
{
var docData = Marshal.GetObjectForIUnknown(docDataPtr);
_vsTextLines = docData as IVsTextLines;
var vsTextBuffer = (IVsTextBuffer)docData;
var editorAdapterFactoryService = serviceProvider.GetMefService <IVsEditorAdaptersFactoryService>();
_buffer = editorAdapterFactoryService.GetDocumentBuffer(vsTextBuffer);
if (needsUndoDisabled)
{
Marshal.ThrowExceptionForHR(vsTextBuffer.GetUndoManager(out _manager));
Marshal.ThrowExceptionForHR((_manager as IVsUndoState).IsEnabled(out var isEnabled));
_needsUndoRestored = isEnabled != 0;
if (_needsUndoRestored)
{
_manager.DiscardFrom(null); // Discard the undo history for this document
_manager.Enable(0); // Disable Undo for this document
}
}
}
finally
{
Marshal.Release(docDataPtr);
}
}
finally
{
// We need to clean up the extra reference we have, now that we have an RCW holding onto the object.
Marshal.Release(invisibleEditorPtr);
}
}
public void AddProject(AbstractProject project)
{
var creationInfo = new VisualStudioProjectCreationInfo
{
AssemblyName = project.AssemblyName,
FilePath = project.ProjectFilePath,
Hierarchy = project.Hierarchy,
ProjectGuid = project.Guid,
};
project.VisualStudioProject = _projectFactory.CreateAndAddToWorkspace(project.ProjectSystemName, project.Language, creationInfo);
project.UpdateVisualStudioProjectProperties();
_typeScriptProjects[project.Id] = project;
}
internal bool TryGetProjectByBinPath(string filePath, out AbstractProject project)
{
var projectsWithBinPath = _workspace.CurrentSolution.Projects.Where(p => string.Equals(p.OutputFilePath, filePath, StringComparison.OrdinalIgnoreCase)).ToList();
if (projectsWithBinPath.Count == 1)
{
project = new StubProject(this, projectsWithBinPath[0]);
return(true);
}
else
{
project = null;
return(false);
}
}
/// <summary>
/// Updates the project tracker and referencing projects for binary output path change for the given project.
/// </summary>
internal void UpdateProjectBinPath(AbstractProject project, string oldBinPathOpt, string newBinPathOpt)
{
// UpdateProjectBinPath is defensively executed on the foreground thread as it calls back into referencing projects to perform metadata to P2P reference conversions.
AssertIsForeground();
if (oldBinPathOpt != null)
{
UpdateReferencesForBinPathChange(oldBinPathOpt, () => RemoveProjectByBinPath(oldBinPathOpt, project));
}
if (newBinPathOpt != null)
{
UpdateReferencesForBinPathChange(newBinPathOpt, () => AddProjectByBinPath(newBinPathOpt, project));
}
}
/// <summary>
/// Add a project to the workspace.
/// </summary>
internal void AddProject(AbstractProject project)
{
_projectMap.Add(project.Id, project);
UpdateProjectBinPath(project, null, project.TryGetBinOutputPath());
if (_solutionLoadComplete)
{
StartPushingToWorkspaceAndNotifyOfOpenDocuments(SpecializedCollections.SingletonEnumerable(project));
}
else
{
_projectsLoadedThisBatch.Add(project);
}
}
internal void RemoveProjectByBinPath(string filePath, AbstractProject project)
{
lock (_gate)
{
if (_projectsByBinPath.TryGetValue(filePath, out var projects) && projects.Contains(project))
{
if (projects.Length == 1)
{
_projectsByBinPath.Remove(filePath);
}
else
{
_projectsByBinPath[filePath] = projects.Remove(project);
}
}
}
}
private ProjectItem AddDocumentToProject(
AbstractProject hostProject,
EnvDTE.Project project,
DocumentId documentId,
string documentName,
SourceCodeKind sourceCodeKind,
SourceText initialText = null,
string filePath = null,
bool isAdditionalDocument = false)
{
if (!project.TryGetFullPath(out var folderPath))
{
// TODO(cyrusn): Throw an appropriate exception here.
throw new Exception(ServicesVSResources.Could_not_find_location_of_folder_on_disk);
}
return(AddDocumentToProjectItems(hostProject, project.ProjectItems, documentId, folderPath, documentName, sourceCodeKind, initialText, filePath, isAdditionalDocument));
}
/// <summary>
/// Attempts to get single project by given output binary filePath.
/// </summary>
/// <remarks>This method may be called on a background thread.</remarks>
internal bool TryGetProjectByBinPath(string filePath, out AbstractProject project)
{
lock (_gate)
{
project = null;
if (_projectsByBinPath.TryGetValue(filePath, out var projects))
{
// If for some reason we have more than one referencing project, it's ambiguous so bail
if (projects.Length == 1)
{
project = projects[0];
return(true);
}
}
return(false);
}
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
AssertIsForeground();
lock (_gate)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
}
UpdateProjectBinPath(project, project.BinOutputPath, null);
if (_pushedProjects.Contains(project))
{
NotifyWorkspace(workspace => workspace.OnProjectRemoved(project.Id));
_pushedProjects.Remove(project);
}
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
AssertIsForeground();
lock (_gate)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
}
UpdateProjectBinPath(project, project.BinOutputPath, null);
using (Dispatcher.CurrentDispatcher.DisableProcessing())
{
foreach (var hostState in _workspaceHosts)
{
hostState.RemoveProject(project);
}
}
}
private void AddToPushListIfNeeded(AbstractProject project, List<AbstractProject> inOrderToPush, HashSet<AbstractProject> visited)
{
if (_pushedProjects.Contains(project))
{
return;
}
if (!visited.Add(project))
{
return;
}
foreach (var projectReference in project.GetCurrentProjectReferences())
{
AddToPushListIfNeeded(_tracker._projectMap[projectReference.ProjectId], inOrderToPush, visited);
}
inOrderToPush.Add(project);
}
private void AddToPushListIfNeeded(AbstractProject project, List<AbstractProject> inOrderToPush, HashSet<AbstractProject> visited)
{
AssertIsForeground();
Contract.ThrowIfFalse(_tracker.ContainsProject(project));
// Bail out if any of the following is true:
// 1. We have already started pushing changes for this project OR
// 2. We have already visited this project in a prior recursive call
if (_pushedProjects.Contains(project) || !visited.Add(project))
{
return;
}
foreach (var projectReference in project.GetCurrentProjectReferences())
{
AddToPushListIfNeeded(_tracker.GetProject(projectReference.ProjectId), inOrderToPush, visited);
}
inOrderToPush.Add(project);
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
UpdateProjectBinPath(project, project.TryGetBinOutputPath(), null);
if (project.PushingChangesToWorkspaceHosts)
{
NotifyWorkspaceHosts(host => host.OnProjectRemoved(project.Id));
}
}
/// <summary>
/// Updates the project tracker and referencing projects for binary output path change for the given project.
/// If invoked on the foreground thread, the update is executed right away.
/// Otherwise, update is scheduled on foreground task scheduler.
/// </summary>
/// <remarks>This method may be called on a background thread.</remarks>
internal void UpdateProjectBinPath(AbstractProject project, string oldBinPathOpt, string newBinPathOpt)
{
ExecuteOrScheduleForegroundAffinitizedAction(() => UpdateProjectBinPath_Foreground(project, oldBinPathOpt, newBinPathOpt));
}
internal bool ContainsProject(AbstractProject project)
{
lock (_gate)
{
return _projectMap.ContainsKey(project.Id);
}
}
internal void UpdateProjectBinPath(AbstractProject project, string oldBinPathOpt, string newBinPathOpt)
{
if (oldBinPathOpt != null)
{
UpdateReferencesForBinPathChange(oldBinPathOpt, () => _projectsByBinPath.MultiRemove(oldBinPathOpt, project));
}
if (newBinPathOpt != null)
{
UpdateReferencesForBinPathChange(newBinPathOpt, () => _projectsByBinPath.MultiAdd(newBinPathOpt, project));
}
}
internal void AddProjectByBinPath(string filePath, AbstractProject project)
{
lock (_gate)
{
if (!_projectsByBinPath.TryGetValue(filePath, out var projects))
{
projects = ImmutableArray<AbstractProject>.Empty;
}
_projectsByBinPath[filePath] = projects.Add(project);
}
}
internal void RemoveProjectByBinPath(string filePath, AbstractProject project)
{
lock (_gate)
{
if (_projectsByBinPath.TryGetValue(filePath, out var projects) && projects.Contains(project))
{
if (projects.Length == 1)
{
_projectsByBinPath.Remove(filePath);
}
else
{
_projectsByBinPath[filePath] = projects.Remove(project);
}
}
}
}
internal void UpdateProjectBinPath_Foreground(AbstractProject project, string oldBinPathOpt, string newBinPathOpt)
{
// UpdateProjectBinPath is defensively executed on the foreground thread as it calls back into referencing projects to perform metadata to P2P reference conversions.
AssertIsForeground();
if (oldBinPathOpt != null)
{
UpdateReferencesForBinPathChange(oldBinPathOpt, () => RemoveProjectByBinPath(oldBinPathOpt, project));
}
if (newBinPathOpt != null)
{
UpdateReferencesForBinPathChange(newBinPathOpt, () => AddProjectByBinPath(newBinPathOpt, project));
}
}
/// <summary>
/// Attempts to get single project by given output binary filePath.
/// </summary>
/// <remarks>This method may be called on a background thread.</remarks>
internal bool TryGetProjectByBinPath(string filePath, out AbstractProject project)
{
lock (_gate)
{
project = null;
if (_projectsByBinPath.TryGetValue(filePath, out var projects))
{
// If for some reason we have more than one referencing project, it's ambiguous so bail
if (projects.Length == 1)
{
project = projects[0];
return true;
}
}
return false;
}
}
internal void RemoveProject(AbstractProject project)
{
// If we've already told this host about it, then we need to remove it. Otherwise, this host has no
// further work to do.
if (_pushedProjects.Remove(project))
{
this.Host.OnProjectRemoved(project.Id);
}
}
/// <summary>
/// Add a project to the workspace.
/// </summary>
internal void AddProject(AbstractProject project)
{
_projectMap.Add(project.Id, project);
UpdateProjectBinPath(project, null, project.TryGetBinOutputPath());
if (_solutionLoadComplete)
{
StartPushingToWorkspaceAndNotifyOfOpenDocuments(SpecializedCollections.SingletonEnumerable(project));
}
else
{
_projectsLoadedThisBatch.Add(project);
}
}
internal CodeModelProjectCache(AbstractProject project, IServiceProvider serviceProvider, HostLanguageServices languageServices, VisualStudioWorkspace workspace)
{
_project = project;
_state = new CodeModelState(serviceProvider, languageServices, workspace);
}
internal VsENCRebuildableProjectImpl(AbstractProject project)
{
_vsProject = project;
_encService = _vsProject.VisualStudioWorkspace.Services.GetService<IEditAndContinueWorkspaceService>();
_trackingService = _vsProject.VisualStudioWorkspace.Services.GetService<IActiveStatementTrackingService>();
_notifications = _vsProject.VisualStudioWorkspace.Services.GetService<INotificationService>();
_debugEncNotify = (IDebugEncNotify)project.ServiceProvider.GetService(typeof(ShellInterop.SVsShellDebugger));
var componentModel = (IComponentModel)project.ServiceProvider.GetService(typeof(SComponentModel));
_diagnosticProvider = componentModel.GetService<EditAndContinueDiagnosticUpdateSource>();
_editorAdaptersFactoryService = componentModel.GetService<IVsEditorAdaptersFactoryService>();
Debug.Assert(_encService != null);
Debug.Assert(_trackingService != null);
Debug.Assert(_diagnosticProvider != null);
Debug.Assert(_editorAdaptersFactoryService != null);
}
protected void UpdateProjectReferenceAliases(AbstractProject referencedProject, ImmutableArray<string> aliases)
{
AssertIsForeground();
var projectReference = GetCurrentProjectReferences().Single(r => r.ProjectId == referencedProject.Id);
var newProjectReference = new ProjectReference(referencedProject.Id, aliases, projectReference.EmbedInteropTypes);
// Is this a project with converted references? If so, make sure we track it
string referenceBinPath = referencedProject.BinOutputPath;
if (referenceBinPath != null && HasMetadataFileNameToConvertedProjectReference(referenceBinPath))
{
UpdateMetadataFileNameToConvertedProjectReference(referenceBinPath, newProjectReference);
}
// Remove the existing reference first
RemoveProjectReference(projectReference);
AddProjectReference(newProjectReference);
}
internal void TryProjectConversionForIntroducedOutputPath(string binPath, AbstractProject projectToReference)
{
AssertIsForeground();
if (this.CanConvertToProjectReferences)
{
// We should not already have references for this, since we're only introducing the path for the first time
Contract.ThrowIfTrue(HasMetadataFileNameToConvertedProjectReference(binPath));
var metadataReference = TryGetCurrentMetadataReference(binPath);
if (metadataReference != null)
{
var projectReference = new ProjectReference(
projectToReference.Id,
metadataReference.Properties.Aliases,
metadataReference.Properties.EmbedInteropTypes);
if (CanAddProjectReference(projectReference))
{
RemoveMetadataReferenceCore(metadataReference, disposeReference: true);
AddProjectReference(projectReference);
AddMetadataFileNameToConvertedProjectReference(binPath, projectReference);
}
}
}
}
private bool TryCreateXamlDocument(AbstractProject project, string filePath, out IVisualStudioHostDocument vsDocument)
{
vsDocument = _vsWorkspace.ProjectTracker.DocumentProvider.TryGetDocumentForFile(
project, ImmutableArray<string>.Empty, filePath, SourceCodeKind.Regular, tb => tb.ContentType.IsOfType(ContentTypeNames.XamlContentType));
return vsDocument != null;
}
protected void UpdateProjectReferenceAliases(AbstractProject referencedProject, ImmutableArray<string> aliases)
{
var projectReference = GetCurrentProjectReferences().Single(r => r.ProjectId == referencedProject.Id);
var newProjectReference = new ProjectReference(referencedProject.Id, aliases, projectReference.EmbedInteropTypes);
// Is this a project with converted references? If so, make sure we track it
string referenceBinPath = referencedProject.TryGetBinOutputPath();
if (referenceBinPath != null && _metadataFileNameToConvertedProjectReference.ContainsKey(referenceBinPath))
{
_metadataFileNameToConvertedProjectReference[referenceBinPath] = newProjectReference;
}
// Remove the existing reference first
RemoveProjectReference(projectReference);
AddProjectReference(newProjectReference);
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
private void RemoveProject_Foreground(AbstractProject project)
{
AssertIsForeground();
lock (_gate)
{
Contract.ThrowIfFalse(_projectMap.Remove(project.Id));
}
UpdateProjectBinPath_Foreground(project, project.BinOutputPath, null);
using (Dispatcher.CurrentDispatcher.DisableProcessing())
{
foreach (var hostState in _workspaceHosts)
{
hostState.RemoveProject(project);
}
}
}
private bool TryCreateXamlDocument(AbstractProject project, string filePath, out IVisualStudioHostDocument vsDocument)
{
vsDocument = _vsWorkspace.ProjectTracker.DocumentProvider.TryGetDocumentForFile(
project, filePath, SourceCodeKind.Regular,
tb => tb.ContentType.IsOfType(ContentTypeNames.XamlContentType),
_ => SpecializedCollections.EmptyReadOnlyList<string>());
return vsDocument != null;
}
public AbstractProjectCodeModel(AbstractProject project, VisualStudioWorkspaceImpl visualStudioWorkspace, IServiceProvider serviceProvider)
{
VSProject = project;
VisualStudioWorkspace = visualStudioWorkspace;
ServiceProvider = serviceProvider;
}
private static void StartPushingToWorkspaceAndNotifyOfOpenDocuments(AbstractProject project)
{
project.AssertIsForeground();
// If a document is opened in a project but we haven't started pushing yet, we want to stop doing lazy
// loading for this project and get it up to date so the user gets a fast experience there. If the file
// was presented as open to us right away, then we'll never do this in OnDocumentOpened, so we should do
// it here. It's important to do this after everything else happens in this method, so we don't get
// strange ordering issues. It's still possible that this won't actually push changes if the workspace
// host isn't ready to receive events yet.
project.ProjectTracker.StartPushingToWorkspaceAndNotifyOfOpenDocuments(SpecializedCollections.SingletonEnumerable(project));
}
private void AddProject_Foreground(AbstractProject project)
{
AssertIsForeground();
lock (_gate)
{
_projectMap.Add(project.Id, project);
}
// UpdateProjectBinPath is defensively executed on the foreground thread as it calls back into referencing projects to perform metadata to P2P reference conversions.
UpdateProjectBinPath_Foreground(project, null, project.BinOutputPath);
if (_solutionLoadComplete)
{
StartPushingToWorkspaceAndNotifyOfOpenDocuments_Foreground(SpecializedCollections.SingletonEnumerable(project));
}
else
{
_projectsLoadedThisBatch.Add(project);
}
}
/// <summary>
/// Remove a project from the workspace.
/// </summary>
internal void RemoveProject(AbstractProject project)
{
ExecuteOrScheduleForegroundAffinitizedAction(() => RemoveProject_Foreground(project));
}
public AbstractProjectCodeModel(AbstractProject project, VisualStudioWorkspace visualStudioWorkspace, IServiceProvider serviceProvider)
{
_vsProject = project;
_visualStudioWorkspace = visualStudioWorkspace;
_serviceProvider = serviceProvider;
}
