internal async Task <MonoDevelopWorkspace> CreateEmptyWorkspace()
{
var ws = new MonoDevelopWorkspace(compositionManager.HostServices, null, this);
await ws.Initialize();
return(ws);
}
public void TestDataHandling()
{
using (var project = Services.ProjectService.CreateDotNetProject("C#"))
using (var workspace = new MonoDevelopWorkspace(null)) {
var map = new MonoDevelopWorkspace.ProjectDataMap(workspace);
var pid = map.GetOrCreateId(project, null);
var data = map.GetData(pid);
Assert.IsNull(data);
Assert.IsFalse(map.Contains(pid));
data = map.CreateData(pid, ImmutableArray <MonoDevelopMetadataReference> .Empty);
Assert.IsNotNull(data);
Assert.IsTrue(map.Contains(pid));
map.RemoveData(pid);
data = map.GetData(pid);
Assert.IsNull(data);
Assert.IsFalse(map.Contains(pid));
}
}
public void TestSimpleCreation()
{
using (var project = Services.ProjectService.CreateDotNetProject("C#"))
using (var workspace = new MonoDevelopWorkspace(null)) {
var map = new MonoDevelopWorkspace.ProjectDataMap(workspace);
var pid = map.GetId(project);
Assert.IsNull(pid);
pid = map.GetOrCreateId(project, null);
Assert.IsNotNull(pid);
var projectInMap = map.GetMonoProject(pid);
Assert.AreSame(project, projectInMap);
var projectRemovedFromMap = map.RemoveProject(pid);
Assert.AreSame(projectInMap, projectRemovedFromMap);
Assert.IsNull(map.GetId(project));
pid = map.GetOrCreateId(project, null);
map.RemoveProject(project);
Assert.IsNull(map.GetId(project));
}
}
static async Task AddAssemblyReference(MonoDevelopWorkspace ws, DotNetProject from, DotNetProject to, string name)
{
var manager = ws.MetadataReferenceManager;
var assemblies = await from.GetReferencedAssemblies(IdeApp.Workspace?.ActiveConfiguration ?? ConfigurationSelector.Default);
var messagingAsm = assemblies.Single(x => x.Metadata.GetValue <string> ("Filename") == name);
var metadataReference = manager.GetOrCreateMetadataReference(messagingAsm.FilePath, MetadataReferenceProperties.Assembly);
await FileWatcherService.Update();
var roslynProj = ws.GetProjectId(to);
var oldRefs = ws.CurrentSolution.GetProject(roslynProj).MetadataReferences;
var newRefs = oldRefs.ToImmutableArray().Add(metadataReference.CurrentSnapshot);
var newSolution = ws.CurrentSolution.WithProjectMetadataReferences(roslynProj, newRefs);
Assert.IsTrue(ws.TryApplyChanges(newSolution));
await ws.ProjectSaveTask;
var reference = to.References.Single(x => x.Include == name);
Assert.IsTrue(reference.HintPath.IsNull);
Assert.AreEqual(ReferenceType.Package, reference.ReferenceType);
}
public ProjectSystemHandler(MonoDevelopWorkspace workspace, ProjectDataMap projectMap, ProjectionData projections)
{
this.workspace = workspace;
this.projectMap = projectMap;
this.projections = projections;
metadataHandler = new Lazy <MetadataReferenceHandler> (() => new MetadataReferenceHandler(workspace.MetadataReferenceManager, projectMap));
}
void LoadCache(Solution sol)
{
var solConfig = sol.GetConfiguration(IdeServices.Workspace.ActiveConfiguration);
if (solConfig == null)
{
return;
}
var serializer = new JsonSerializer();
foreach (var project in sol.GetAllProjects())
{
var config = solConfig.GetMappedConfiguration(project);
var projectFilePath = project.FileName;
string cacheFilePath = null;
List <ProjectCache> cacheList = null;
foreach (string framework in MonoDevelopWorkspace.GetFrameworks(project))
{
try {
cacheFilePath = GetProjectCacheFile(project, config, framework);
if (!File.Exists(cacheFilePath))
{
continue;
}
using (var sr = File.OpenText(cacheFilePath)) {
var value = (ProjectCache)serializer.Deserialize(sr, typeof(ProjectCache));
if (format != value.Format)
{
continue;
}
value.Framework = framework;
if (cacheList == null)
{
cacheList = new List <ProjectCache> ();
}
cacheList.Add(value);
}
} catch (Exception ex) {
LoggingService.LogError("Could not deserialize project cache", ex);
TryDeleteFile(cacheFilePath);
continue;
}
}
if (cacheList != null)
{
cachedItems [projectFilePath] = cacheList;
}
}
}
public ProjectSystemHandler(MonoDevelopWorkspace workspace, ProjectDataMap projectMap, ProjectionData projections)
{
this.workspace = workspace;
this.projectMap = projectMap;
this.projections = projections;
metadataHandler = new Lazy <MetadataReferenceHandler> (() => new MetadataReferenceHandler(workspace.MetadataReferenceManager, projectMap));
hostDiagnosticUpdateSource = new Lazy <HostDiagnosticUpdateSource> (() => new HostDiagnosticUpdateSource(workspace, Composition.CompositionManager.GetExportedValue <IDiagnosticUpdateSourceRegistrationService> ()));
}
public void TestEmptyMetadataCreation()
{
var pid = ProjectId.CreateNewId();
using (var workspace = new MonoDevelopWorkspace(null))
using (var data = new MonoDevelopWorkspace.ProjectData(pid, ImmutableArray <MonoDevelopMetadataReference> .Empty, workspace)) {
// Do nothing, we just want to see it construct and dispose properly.
}
}
public void TestMigration()
{
using (var project = Services.ProjectService.CreateDotNetProject("C#"))
using (var project2 = Services.ProjectService.CreateDotNetProject("C#"))
using (var workspace = new MonoDevelopWorkspace(null)) {
var map = new MonoDevelopWorkspace.ProjectDataMap(workspace);
var pid = map.GetOrCreateId(project, null);
Assert.IsNotNull(pid);
var pid2 = map.GetOrCreateId(project2, project);
Assert.AreSame(pid, pid2);
}
}
internal void Complete(MonoDevelopWorkspace workspace)
{
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
lock (requests) {
foreach (var request in requests.ToList())
{
// Requests are removed when completed.
request.TrySetResult(workspace);
}
}
}
protected override async Task OnInitialize(ServiceProvider serviceProvider)
{
IntitializeTrackedProjectHandling();
serviceProvider.WhenServiceInitialized <CompositionManager> (s => {
miscellaneousFilesWorkspace = CompositionManager.Instance.GetExportedValue <MiscellaneousFilesWorkspace> ();
serviceProvider.WhenServiceInitialized <DocumentManager> (dm => {
documentManager = dm;
});
});
serviceProvider.WhenServiceInitialized <RootWorkspace> (s => {
rootWorkspace = s;
rootWorkspace.ActiveConfigurationChanged += HandleActiveConfigurationChanged;
});
RoslynServices.RoslynService.Initialize();
CleanupCache();
#pragma warning disable CS0618, 612 // Type or member is obsolete
parsers = AddinManager.GetExtensionNodes <TypeSystemParserNode> ("/MonoDevelop/TypeSystem/Parser");
bool initialLoad = true;
AddinManager.AddExtensionNodeHandler("/MonoDevelop/TypeSystem/Parser", delegate(object sender, ExtensionNodeEventArgs args) {
//refresh entire list to respect insertbefore/insertafter ordering
if (!initialLoad)
{
parsers = AddinManager.GetExtensionNodes <TypeSystemParserNode> ("/MonoDevelop/TypeSystem/Parser");
}
});
#pragma warning restore CS0618, 612 // Type or member is obsolete
initialLoad = false;
try {
compositionManager = await serviceProvider.GetService <CompositionManager> ().ConfigureAwait(false);
emptyWorkspace = new MonoDevelopWorkspace(compositionManager.HostServices, null, this);
await emptyWorkspace.Initialize().ConfigureAwait(false);
} catch (Exception e) {
LoggingService.LogFatalError("Can't create roslyn workspace", e);
}
FileService.FileChanged += FileService_FileChanged;
FileService.FileRemoved += FileService_FileRemoved;
desktopService = await serviceProvider.GetService <DesktopService> ();
await serviceProvider.GetService <HelpService> ();
}
internal void Unload(MonoDevelop.Projects.WorkspaceItem item)
{
var ws = item as MonoDevelop.Projects.Workspace;
if (ws != null)
{
foreach (var it in ws.Items)
{
Unload(it);
}
ws.ItemAdded -= OnWorkspaceItemAdded;
ws.ItemRemoved -= OnWorkspaceItemRemoved;
MonoDocDocumentationProvider.ClearCommentCache();
}
else
{
var solution = item as MonoDevelop.Projects.Solution;
if (solution != null)
{
MonoDevelopWorkspace result = GetWorkspace(solution);
if (result != emptyWorkspace)
{
lock (workspaceLock)
workspaces = workspaces.Remove(result);
result.Dispose();
}
lock (solution.ExtendedProperties.SyncRoot) {
if (solution.ExtendedProperties [typeof(WorkspaceRequestRegistration)] is WorkspaceRequestRegistration registration)
{
registration.Dispose();
}
}
solution.SolutionItemAdded -= OnSolutionItemAdded;
solution.SolutionItemRemoved -= OnSolutionItemRemoved;
if (solution.ParentWorkspace == null)
{
MonoDocDocumentationProvider.ClearCommentCache();
}
}
}
}
static Task InternalLoad(List <MonoDevelopWorkspace> list, MonoDevelop.Projects.WorkspaceItem item, ProgressMonitor progressMonitor, CancellationToken cancellationToken = default(CancellationToken), bool showStatusIcon = true)
{
return(Task.Run(async() => {
var ws = item as MonoDevelop.Projects.Workspace;
if (ws != null)
{
foreach (var it in ws.Items)
{
await InternalLoad(list, it, progressMonitor, cancellationToken).ConfigureAwait(false);
}
ws.ItemAdded += OnWorkspaceItemAdded;
ws.ItemRemoved += OnWorkspaceItemRemoved;
}
else
{
var solution = item as MonoDevelop.Projects.Solution;
if (solution != null)
{
var workspace = new MonoDevelopWorkspace(solution);
lock (workspaceLock)
workspaces = workspaces.Add(workspace);
list.Add(workspace);
if (showStatusIcon)
{
workspace.ShowStatusIcon();
}
await workspace.TryLoadSolution(cancellationToken).ConfigureAwait(false);
solution.SolutionItemAdded += OnSolutionItemAdded;
solution.SolutionItemRemoved += OnSolutionItemRemoved;
TaskCompletionSource <MonoDevelopWorkspace> request;
if (workspaceRequests.TryGetValue(solution, out request))
{
request.TrySetResult(workspace);
}
if (showStatusIcon)
{
workspace.HideStatusIcon();
}
}
}
}));
}
async Task CreateWorkspaces(WorkspaceItem item, List <MonoDevelopWorkspace> result)
{
if (item is MonoDevelop.Projects.Workspace ws)
{
foreach (var wsItem in ws.Items)
{
await CreateWorkspaces(wsItem, result).ConfigureAwait(false);
}
ws.ItemAdded += OnWorkspaceItemAdded;
ws.ItemRemoved += OnWorkspaceItemRemoved;
}
else if (item is MonoDevelop.Projects.Solution solution)
{
var workspace = new MonoDevelopWorkspace(compositionManager.HostServices, solution, this);
await workspace.Initialize().ConfigureAwait(false);
lock (workspaceLock)
workspaces = workspaces.Add(workspace);
solution.SolutionItemAdded += OnSolutionItemAdded;
solution.SolutionItemRemoved += OnSolutionItemRemoved;
result.Add(workspace);
}
}
public ProjectData(ProjectId projectId, ImmutableArray <MonoDevelopMetadataReference> metadataReferences, MonoDevelopWorkspace ws)
{
this.projectId = projectId;
workspaceRef = new WeakReference <MonoDevelopWorkspace> (ws);
DocumentData = new DocumentMap(projectId);
this.metadataReferences = new List <MonoDevelopMetadataReference> (metadataReferences.Length);
System.Diagnostics.Debug.Assert(Monitor.IsEntered(ws.updatingProjectDataLock));
foreach (var metadataReference in metadataReferences)
{
AddMetadataReference_NoLock(metadataReference, ws);
}
}
void AddMetadataReference_NoLock(MonoDevelopMetadataReference metadataReference, MonoDevelopWorkspace ws)
{
System.Diagnostics.Debug.Assert(Monitor.IsEntered(metadataReferences));
metadataReferences.Add(metadataReference);
metadataReference.SnapshotUpdated += OnMetadataReferenceUpdated;
}
void AddMetadataReference_NoLock(MonoDevelopMetadataReference metadataReference, MonoDevelopWorkspace ws)
{
System.Diagnostics.Debug.Assert(Monitor.IsEntered(ws.updatingProjectDataLock));
metadataReferences.Add(metadataReference);
metadataReference.UpdatedOnDisk += OnMetadataReferenceUpdated;
}
static void NotifySolutionModified(MonoDevelop.Projects.Solution sol, SolutionId solId, MonoDevelopWorkspace workspace)
{
if (string.IsNullOrWhiteSpace(sol.BaseDirectory))
{
return;
}
var locService = (MonoDevelopPersistentStorageLocationService)workspace.Services.GetService <IPersistentStorageLocationService> ();
locService.NotifyStorageLocationChanging(solId, sol.GetPreferencesDirectory());
}
static Task InternalLoad (List<MonoDevelopWorkspace> list, MonoDevelop.Projects.WorkspaceItem item, ProgressMonitor progressMonitor, CancellationToken cancellationToken = default(CancellationToken))
{
return Task.Run (async () => {
var ws = item as MonoDevelop.Projects.Workspace;
if (ws != null) {
foreach (var it in ws.Items) {
await InternalLoad (list, it, progressMonitor, cancellationToken);
}
ws.ItemAdded += OnWorkspaceItemAdded;
ws.ItemRemoved += OnWorkspaceItemRemoved;
} else {
var solution = item as MonoDevelop.Projects.Solution;
if (solution != null) {
var workspace = new MonoDevelopWorkspace ();
list.Add (workspace);
workspace.ShowStatusIcon ();
lock (workspaceLock)
workspaces = workspaces.Add (workspace);
await workspace.TryLoadSolution (solution, cancellationToken);
solution.SolutionItemAdded += OnSolutionItemAdded;
solution.SolutionItemRemoved += OnSolutionItemRemoved;
workspace.HideStatusIcon ();
}
}
});
}
bool RemoveMetadataReference_NoLock(MonoDevelopMetadataReference metadataReference, MonoDevelopWorkspace ws)
{
System.Diagnostics.Debug.Assert(Monitor.IsEntered(ws.updatingProjectDataLock));
metadataReference.UpdatedOnDisk -= OnMetadataReferenceUpdated;
return(metadataReferences.Remove(metadataReference));
}
async void OnSolutionItemAdded(object sender, MonoDevelop.Projects.SolutionItemChangeEventArgs args)
{
try {
var project = args.SolutionItem as MonoDevelop.Projects.Project;
if (project != null)
{
var ws = GetWorkspace(args.Solution);
var oldProject = args.ReplacedItem as MonoDevelop.Projects.Project;
// when loading a project that was unloaded manually before
// args.ReplacedItem is the UnloadedSolutionItem, which is not useful
// we need to find what was the real project previously
if (args.Reloading && oldProject == null)
{
var existingRoslynProject = ws.CurrentSolution.Projects.FirstOrDefault(p => p.FilePath == project.FileName);
if (existingRoslynProject != null)
{
oldProject = ws.GetMonoProject(existingRoslynProject.Id);
}
}
HashSet <ProjectId> oldProjectIds = null;
if (oldProject != null)
{
oldProjectIds = ws.GetProjectIds(oldProject).ToHashSet();
}
foreach (string framework in MonoDevelopWorkspace.GetFrameworks(project))
{
var projectInfo = await ws.LoadProject(project, CancellationToken.None, oldProject, framework);
if (oldProject != null)
{
if (oldProjectIds.Remove(projectInfo.Id))
{
ws.OnProjectReloaded(projectInfo);
}
else
{
ws.OnProjectAdded(projectInfo);
}
}
else
{
ws.OnProjectAdded(projectInfo);
}
}
if (oldProjectIds != null)
{
foreach (var removedProjectId in oldProjectIds)
{
ws.OnProjectRemoved(removedProjectId);
}
}
ws.ReloadModifiedProject(project);
Runtime.RunInMainThread(() => IdeServices.TypeSystemService.UpdateRegisteredOpenDocuments()).Ignore();
}
} catch (Exception ex) {
LoggingService.LogError("OnSolutionItemAdded failed", ex);
}
}
public ProjectData(ProjectId projectId, ImmutableArray <MonoDevelopMetadataReference> metadataReferences, MonoDevelopWorkspace ws)
{
this.projectId = projectId;
workspaceRef = new WeakReference <MonoDevelopWorkspace> (ws);
DocumentData = new DocumentMap(projectId);
this.metadataReferences = new List <MonoDevelopMetadataReference> (metadataReferences);
}
bool RemoveMetadataReference_NoLock(MonoDevelopMetadataReference metadataReference, MonoDevelopWorkspace ws)
{
System.Diagnostics.Debug.Assert(Monitor.IsEntered(metadataReferences));
metadataReference.SnapshotUpdated -= OnMetadataReferenceUpdated;
return(metadataReferences.Remove(metadataReference));
}