diff --git a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/CompanionSaveWatcher.cs b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/CompanionSaveWatcher.cs index da5d22a6a9..af068eecc2 100644 --- a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/CompanionSaveWatcher.cs +++ b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/CompanionSaveWatcher.cs @@ -39,9 +39,9 @@ namespace XSharp.ProjectSystem.ShadowDesigner /// /// "On save" specifically (via IVsRunningDocTableEvents.OnAfterSave), not an idle timer /// or tab-switch hook: both sync commands read the companion files from disk, not the - /// live editor buffer -- the same reason the manual commands force-run File.SaveAll - /// first. So on-save is the earliest moment the data is actually available, not an - /// arbitrary cadence choice. + /// live editor buffer, which is also why the other companion documents are saved first + /// (SaveCompanionDocuments). So on-save is the earliest moment the data is actually + /// available, not an arbitrary cadence choice. /// /// Also intercepts the Designer navigating to the companion file's CODE view /// (event-handler creation/navigation) via OnBeforeDocumentWindowShow, and redirects to @@ -144,11 +144,6 @@ public int OnAfterSave(uint docCookie) string path = GetDocumentMoniker(docCookie); if (string.IsNullOrEmpty(path)) { - // Not Form1.cs/Form1.Designer.cs -- still worth checking whether this is a - // .resx living directly in a known companion folder (e.g. a new - // Form1.nl.resx from changing the form's Language property), since that can - // be saved without either code file ever becoming dirty. - TryHandleResxOnlySave(path); return VSConstants.S_OK; } @@ -168,9 +163,8 @@ public int OnAfterSave(uint docCookie) // The save that triggered this event only guarantees ONE of the two // companion files is current on disk -- the other may still be dirty in a // different editor tab (e.g. a new handler stub in Form1.cs while only - // Form1.Designer.cs was just saved). Force both current first, same safety - // net the manual sync commands already use. - SaveDirtyDocuments(); + // Form1.Designer.cs was just saved). Force both current first. + SaveCompanionDocuments(location); EventHandlerSync.Sync(location); DesignerChangesSync.Sync(location); CompanionResourceSync.Sync(location); @@ -231,6 +225,11 @@ private void TryHandleResxOnlySave(string path) } } static bool saving = false; + /// + /// Saves every dirty document, before Debug/Start only (VS saves them for the build anyway). Not used by the + /// syncs: called from OnAfterSave, saving the solution as well failed with a recursive save error, see + /// SaveCompanionDocuments. + /// private void SaveDirtyDocuments() { ThreadHelper.ThrowIfNotOnUIThread(); @@ -238,15 +237,63 @@ private void SaveDirtyDocuments() if (! saving) { saving = true; - int hr = _rdt.SaveDocuments((uint)__VSRDTSAVEOPTIONS.RDTSAVEOPT_SaveIfDirty, - null, VSConstants.VSITEMID_NIL, VSConstants.VSCOOKIE_NIL); - ErrorHandler.ThrowOnFailure(hr); - if (hr != VSConstants.S_OK) + try { - throw new InvalidOperationException("Saving documents was cancelled; shadow designer synchronization was not performed."); + int hr = _rdt.SaveDocuments((uint)__VSRDTSAVEOPTIONS.RDTSAVEOPT_SaveIfDirty, + null, VSConstants.VSITEMID_NIL, VSConstants.VSCOOKIE_NIL); + ErrorHandler.ThrowOnFailure(hr); + if (hr != VSConstants.S_OK) + { + throw new InvalidOperationException("Saving documents was cancelled; shadow designer synchronization was not performed."); + } } - saving = false; + finally + { + // Also after a failed or cancelled save, otherwise nothing is saved anymore + saving = false; + } + } + } + /// + /// Saves the companion's own documents that are still dirty (the other code file, a resx), since the syncs + /// read them from disk. Deliberately not all documents (File.SaveAll, SaveDirtyDocuments): that also saved + /// the user's other documents and unsaved solution changes (which is how the companion ended up in the saved + /// solution file), and saving the solution from inside OnAfterSave failed with "A recursive save operation + /// is in progress for '....slnx'" (VS 2026, after adding a Solution Folder). + /// + private void SaveCompanionDocuments(CompanionLocation location) + { + ThreadHelper.ThrowIfNotOnUIThread(); + string companionDir = Path.GetDirectoryName(location.CompanionDesignerCsPath); + if (string.IsNullOrEmpty(companionDir) || + ErrorHandler.Failed(_rdt.GetRunningDocumentsEnum(out IEnumRunningDocuments documents)) || documents == null) + { + return; + } + // Collected first: saving while enumerating could change the table + var toSave = new List(); + var cookies = new uint[1]; + while (documents.Next(1, cookies, out uint fetched) == VSConstants.S_OK && fetched == 1) + { + string path = GetDocumentMoniker(cookies[0]); + if (path != null && + string.Equals(Path.GetDirectoryName(path), companionDir, StringComparison.OrdinalIgnoreCase) && + (path.EndsWith(".cs", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".resx", StringComparison.OrdinalIgnoreCase))) + { + toSave.Add(cookies[0]); + } + } + foreach (uint cookie in toSave) + { + if (ErrorHandler.Succeeded(_rdt.GetDocumentInfo(cookie, out _, out _, out _, out string path, out IVsHierarchy hierarchy, out uint itemId, out _))) + { + int hr = _rdt.SaveDocuments((uint)__VSRDTSAVEOPTIONS.RDTSAVEOPT_SaveIfDirty, hierarchy, itemId, cookie); + if (ErrorHandler.Failed(hr)) + { + Logger.Information($"CompanionSaveWatcher: could not save {path}, hr=0x{hr:X8}"); + } + } } } @@ -295,7 +342,7 @@ public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowF // Same reasoning as OnAfterSave: the sync command reads from disk, and the // Designer's own navigation flow may have flushed its pending edits into the // companion buffer without that being on disk yet. - SaveDirtyDocuments(); + SaveCompanionDocuments(location); result = EventHandlerSync.Sync(location); CompanionResourceSync.Sync(location); } @@ -407,6 +454,7 @@ private async Task RedirectNowAsync(CompanionLocation location, IVsWindowFrame c Logger.Exception(ex, "CompanionSaveWatcher.RedirectNowAsync: CloseFrame failed"); } + ReloadOpenDocument(location.MainPrgPath); VsShellUtilities.OpenDocument(ServiceProvider.GlobalProvider, location.MainPrgPath, VSConstants.LOGVIEWID.TextView_guid, out _, out _, out IVsWindowFrame frame); @@ -479,14 +527,19 @@ private static string TryGetCaretMethodName(IVsWindowFrame companionFrame, strin /// /// The returned frame's text view may still be initializing; poll that frame briefly /// rather than navigating whichever document happens to be active. + /// + /// The declaration is searched in the editor buffer, not in the file: a new stub is + /// written to disk by EventHandlerSync, and a .prg that is already open is only + /// reloaded by VS a moment later. A line number taken from the file then pointed past + /// the end of the old, shorter buffer (caret at the end of the file, while a second + /// try worked). RedirectNowAsync therefore reloads the document first + /// (ReloadOpenDocument); the buffer is still polled briefly in case that was skipped. /// private async Task NavigateToMethodAsync(IVsWindowFrame frame, string prgPath, string handlerName) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); - string[] lines = File.ReadAllLines(prgPath); var pattern = new Regex($@"\bMETHOD\s+{Regex.Escape(handlerName)}\s*\(", RegexOptions.IgnoreCase); - int declLineIndex = Array.FindIndex(lines, l => pattern.IsMatch(l)); - if (declLineIndex < 0) + if (!File.ReadLines(prgPath).Any(l => pattern.IsMatch(l))) { return false; } @@ -508,9 +561,32 @@ private async Task NavigateToMethodAsync(IVsWindowFrame frame, string prgP return false; } - int targetLine = (declLineIndex + 1 < lines.Length) ? declLineIndex + 1 : declLineIndex; ErrorHandler.ThrowOnFailure(textView.GetBuffer(out IVsTextLines buffer)); - ErrorHandler.ThrowOnFailure(buffer.GetLineCount(out int lineCount)); + int declLineIndex = -1; + int lineCount = 0; + const int maxAttempts = 40; + for (int attempt = 0; attempt < maxAttempts; attempt++) + { + ErrorHandler.ThrowOnFailure(buffer.GetLineCount(out lineCount)); + declLineIndex = FindLine(buffer, lineCount, pattern); + if (declLineIndex >= 0) + { + if (attempt > 0) + { + Logger.Information($"CompanionSaveWatcher.NavigateToMethodAsync: waited {attempt * 50} ms for {prgPath} to be reloaded"); + } + break; + } + await Task.Delay(50); + await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); + } + if (declLineIndex < 0) + { + Logger.Error($"CompanionSaveWatcher.NavigateToMethodAsync: '{handlerName}' not found in the editor buffer of {prgPath} after {maxAttempts * 50} ms."); + return false; + } + + int targetLine = (declLineIndex + 1 < lineCount) ? declLineIndex + 1 : declLineIndex; int endLine = targetLine; int endColumn; if (targetLine + 1 < lineCount) @@ -533,6 +609,58 @@ private async Task NavigateToMethodAsync(IVsWindowFrame frame, string prgP return true; } + /// + /// Reloads from disk when it is open in an editor without unsaved changes. EventHandlerSync + /// writes new handler stubs to the file; VS reloads an open document only when the UI thread is idle, which + /// never happens while the new-handler redirect runs (JoinableTaskFactory.Run in OnBeforeDocumentWindowShow), + /// so NavigateToMethodAsync would search a buffer without the new stub. A document with unsaved changes is + /// left alone: reloading would lose them. + /// + private void ReloadOpenDocument(string path) + { + ThreadHelper.ThrowIfNotOnUIThread(); + if (ErrorHandler.Failed(_rdt.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, path, + out _, out _, out IntPtr docDataPtr, out _)) || docDataPtr == IntPtr.Zero) + { + return; + } + try + { + if (System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(docDataPtr) is IVsPersistDocData docData && + ErrorHandler.Succeeded(docData.IsDocDataDirty(out int dirty)) && dirty == 0) + { + // The file change notification of the sync's own write would reload it a second time + int hr = docData.ReloadDocData((uint)_VSRELOADDOCDATA.RDD_IgnoreNextFileChange); + Logger.Information($"CompanionSaveWatcher.ReloadOpenDocument: reloaded {path}, hr=0x{hr:X8}"); + } + } + catch (Exception ex) + { + // Best-effort: NavigateToMethodAsync still polls the buffer + Logger.Exception(ex, $"CompanionSaveWatcher.ReloadOpenDocument: could not reload {path}"); + } + finally + { + System.Runtime.InteropServices.Marshal.Release(docDataPtr); + } + } + + /// The 0-based index of the first buffer line matching , or -1. + private static int FindLine(IVsTextLines buffer, int lineCount, Regex pattern) + { + ThreadHelper.ThrowIfNotOnUIThread(); + for (int line = 0; line < lineCount; line++) + { + if (ErrorHandler.Succeeded(buffer.GetLengthOfLine(line, out int length)) && + ErrorHandler.Succeeded(buffer.GetLineText(line, 0, line, length, out string text)) && + pattern.IsMatch(text)) + { + return line; + } + } + return -1; + } + public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining, uint dwEditLocksRemaining) => VSConstants.S_OK; } } diff --git a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/ShadowDesignerCleanup.cs b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/ShadowDesignerCleanup.cs index 4c05e71359..3d06588d62 100644 --- a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/ShadowDesignerCleanup.cs +++ b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/ShadowDesignerCleanup.cs @@ -11,15 +11,10 @@ using System.Collections.Generic; using System.IO; using System.Threading; -using System.Xml; - using Microsoft.VisualStudio; using Microsoft.VisualStudio.Shell; using Microsoft.VisualStudio.Shell.Interop; -using Community.VisualStudio.Toolkit; - - namespace XSharp.ProjectSystem.ShadowDesigner { /// @@ -48,6 +43,12 @@ namespace XSharp.ProjectSystem.ShadowDesigner /// prompt). The companion projects are then no longer in the solution, which is harmless: their paths stay /// tracked, the next View Designer adds the project back (SolutionWiring.EnsureProjectInSolution), and the /// folders are only deleted after a real close. + /// + /// Removing the companion makes the solution dirty. When nothing else was unsaved it is saved right away, so + /// VS does not ask to save the solution because of the companion. When VS does ask (other unsaved changes) and + /// the user answers No, the solution file can still list the companion (saved when it was added, or by a Save + /// All): OnAfterCloseSolution removes it from the file (SolutionFileCleanup), since VS 2026 reports a project + /// that is not found with an error on the next open. /// internal sealed class ShadowDesignerCleanup : IVsSolutionEvents { @@ -68,6 +69,9 @@ internal sealed class ShadowDesignerCleanup : IVsSolutionEvents private readonly IVsSolution _vsSolution; private uint _eventsCookie; + // The file of the closing solution (OnQueryCloseSolution), cleaned in OnAfterCloseSolution + private string _closingSolutionFile; + private ShadowDesignerCleanup(IServiceProvider serviceProvider) { ThreadHelper.ThrowIfNotOnUIThread(); @@ -78,87 +82,8 @@ private ShadowDesignerCleanup(IServiceProvider serviceProvider) } _vsSolution = (IVsSolution)solutionService; ErrorHandler.ThrowOnFailure(_vsSolution.AdviseSolutionEvents(this, out _eventsCookie)); - // Trigger cleanup before solution is closed - VS.Commands.InterceptAsync(VSConstants.VSStd97CmdID.CloseSolution, () => - { - ThreadHelper.ThrowIfNotOnUIThread(); - CleanupAndSave(); - return CommandProgression.Continue; - }).FileAndForget("XSharp/ShadowDesigner/CloseSolution"); - VS.Events.SolutionEvents.OnBeforeCloseSolution += SolutionEvents_OnBeforeCloseSolution; - VS.Events.SolutionEvents.OnAfterCloseSolution += SolutionEvents_OnAfterCloseSolution; } - string solutionName = ""; - private void SolutionEvents_OnBeforeCloseSolution() - { - solutionName = VS.Solutions.GetCurrentSolution().FullPath; - } - - private void SolutionEvents_OnAfterCloseSolution() - { - const string folderName = "Shadow Designer (generated)"; - if (File.Exists(solutionName)) - { - var files = new List(); - foreach (var file in _companionCsprojPaths) - { - files.Add(System.IO.Path.GetFileName(file)); - } - - var text = File.ReadAllText(solutionName); - // Slnx? - if (text.StartsWith("<")) - { - var reader = new StreamReader(solutionName); - var doc = new System.Xml.XmlDocument(); - doc.Load(reader); - reader.Close(); - XmlNode root = doc.DocumentElement; - var nodes = root.SelectNodes("Folder"); - foreach (XmlNode node in nodes) - { - if (node.OuterXml.Contains(folderName)) - { - root.RemoveChild(node); - } - } - doc.Save(solutionName); - return; - - } - // Sln - var lines = File.ReadAllLines(solutionName); - - for (int i = 0; i < lines.Length; i++) - { - var line = lines[i]; - foreach (var file in files) - { - if (line.IndexOf(file, StringComparison.OrdinalIgnoreCase) >= 0) - { - lines[i] = ""; - lines[i + 1] = ""; - } - } - if (line.IndexOf(folderName, StringComparison.OrdinalIgnoreCase) >= 0) - { - lines[i] = ""; - lines[i + 1] = ""; - } - } - File.WriteAllLines(solutionName, lines); - } - solutionName = ""; - } - - private void CleanupAndSave() - { - CleanupSolution(); - VS.Commands.ExecuteAsync(VSConstants.VSStd97CmdID.SaveSolution).FileAndForget("XSharp/ShadowDesigner/SaveSolution"); - } - - /// /// Registers a companion project for cleanup on solution close, lazily advising /// solution events the first time this is called. Safe to call every time @@ -201,10 +126,23 @@ public static void CancelPendingDelete(string companionDir) } } - private void CleanupSolution() + /// + /// Runs for every close (Close Solution, exiting VS, opening another solution), before VS's save prompt. + /// + public int OnQueryCloseSolution(object reserved, ref int cancel) { - if (_vsSolution != null) + // Another listener already cancelled the close: the solution stays open, keep the companions. + if (cancel != 0) { + return VSConstants.S_OK; + } + if (_vsSolution != null && _companionCsprojPaths.Count > 0) + { + _closingSolutionFile = SolutionWiring.GetSolutionFile(_vsSolution); + // Nothing else unsaved: the removal below is the only change, save it without asking (see + // SolutionWiring.EnsureProjectInSolution). Otherwise VS asks as usual; when the user answers No, + // OnAfterCloseSolution removes the companion from the solution file. + bool wasDirty = SolutionWiring.IsSolutionDirty(_vsSolution); foreach (string csprojPath in _companionCsprojPaths) { try @@ -234,11 +172,11 @@ private void CleanupSolution() // Best-effort, see above Logger.Exception(ex, "ShadowDesignerCleanup: could not remove the Solution Folder"); } + if (!wasDirty) + { + SolutionWiring.SaveSolutionFile(_vsSolution, "companion removed"); + } } - } - - public int OnQueryCloseSolution(object reserved, ref int cancel) - { return VSConstants.S_OK; } @@ -376,6 +314,11 @@ public int OnAfterCloseSolution(object reserved) // that could take, retry on a background thread instead -- costs nothing (this is // best-effort cleanup either way) and gives the external process realistic time to // release its handle. + // Answering No to VS's save prompt keeps the companion in the solution file when it was saved earlier + // (EnsureProjectInSolution, or a Save All). The folder is deleted below, so VS would report the project + // as not found on the next open: remove it from the file too. + SolutionFileCleanup.RemoveCompanionProjects(_closingSolutionFile, _companionCsprojPaths); + _closingSolutionFile = null; foreach (string csprojPath in _companionCsprojPaths) { string dir = Path.GetDirectoryName(csprojPath); diff --git a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionFileCleanup.cs b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionFileCleanup.cs new file mode 100644 index 0000000000..adafd616ee --- /dev/null +++ b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionFileCleanup.cs @@ -0,0 +1,228 @@ +// +// Copyright (c) XSharp B.V. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. +// See License.txt in the project root for license information. +// +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; +using System.Xml; +using System.Xml.Linq; + +namespace XSharp.ProjectSystem.ShadowDesigner +{ + /// + /// Removes the companion projects, and the "Shadow Designer (generated)" Solution Folder once it is empty, from a + /// solution file (.slnx or .sln) after VS closed the solution. Only needed when the user answered No to VS's + /// save prompt while the file still listed a companion (see ShadowDesignerCleanup). Only these entries are + /// removed; the rest of the file, its encoding and its line endings are kept. Pure file I/O, no VS API. + /// + internal static class SolutionFileCleanup + { + private const string SolutionFolderTypeGuid = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}"; + + public static void RemoveCompanionProjects(string solutionFile, ICollection companionCsprojPaths) + { + if (string.IsNullOrEmpty(solutionFile) || companionCsprojPaths == null || companionCsprojPaths.Count == 0 || + !File.Exists(solutionFile)) + { + return; + } + try + { + byte[] bytes = File.ReadAllBytes(solutionFile); + bool bom = bytes.Length >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF; + if (!bom && bytes.Length >= 2 && (bytes[0] == 0xFF || bytes[0] == 0xFE)) + { + // UTF-16: not written by VS for .sln/.slnx, left alone + return; + } + var encoding = new UTF8Encoding(bom); + string text = encoding.GetString(bytes, bom ? 3 : 0, bytes.Length - (bom ? 3 : 0)); + string solutionDir = Path.GetDirectoryName(solutionFile); + bool isCompanion(string relativePath) => IsCompanionPath(solutionDir, relativePath, companionCsprojPaths); + + string updated = solutionFile.EndsWith(".slnx", StringComparison.OrdinalIgnoreCase) + ? RemoveFromSlnx(text, isCompanion) + : RemoveFromSln(text, isCompanion); + if (updated == null || updated == text) + { + return; + } + File.WriteAllBytes(solutionFile, encoding.GetPreamble().Concat(encoding.GetBytes(updated)).ToArray()); + Logger.Information($"SolutionFileCleanup: removed the companion projects from {solutionFile}"); + } + catch (Exception ex) + { + // Best-effort: at worst VS reports the project as not found on the next open, and + // SolutionWiring.EnsureProjectInSolution removes the stale entry on the next View Designer + Logger.Exception(ex, $"SolutionFileCleanup: could not clean {solutionFile}"); + } + } + + private static bool IsCompanionPath(string solutionDir, string relativePath, ICollection companionCsprojPaths) + { + if (string.IsNullOrEmpty(relativePath)) + { + return false; + } + try + { + string fullPath = Path.GetFullPath(Path.Combine(solutionDir, relativePath.Replace('/', '\\'))); + return companionCsprojPaths.Any(p => string.Equals(p, fullPath, StringComparison.OrdinalIgnoreCase)); + } + catch (Exception) + { + // Not a valid path, so not a companion + return false; + } + } + + /// + /// .slnx: removes the <Project Path="..."> elements of the companions, then the Solution Folder + /// (<Folder Name="/Shadow Designer (generated)/">) when it has no other content. + /// + private static string RemoveFromSlnx(string text, Func isCompanion) + { + var doc = XDocument.Parse(text, LoadOptions.PreserveWhitespace); + var projects = doc.Descendants("Project").Where(p => isCompanion((string)p.Attribute("Path"))).ToList(); + if (projects.Count == 0) + { + return null; + } + foreach (var project in projects) + { + RemoveWithIndentation(project); + } + string folderName = "/" + SolutionWiring.ShadowDesignerFolderName + "/"; + foreach (var folder in doc.Descendants("Folder").Where(f => (string)f.Attribute("Name") == folderName && !f.HasElements).ToList()) + { + RemoveWithIndentation(folder); + } + + var settings = new XmlWriterSettings + { + OmitXmlDeclaration = doc.Declaration == null, + Encoding = new UTF8Encoding(false), + // XML parsing turned CRLF into LF in the whitespace nodes + NewLineChars = text.Contains("\r\n") ? "\r\n" : "\n", + NewLineHandling = NewLineHandling.Replace, + }; + var builder = new StringBuilder(); + using (var writer = XmlWriter.Create(new StringWriter(builder), settings)) + { + doc.Save(writer); + } + string result = builder.ToString(); + if (doc.Declaration != null) + { + // A StringWriter makes XmlWriter write encoding="utf-16": keep the original declaration + int end = result.IndexOf("?>", StringComparison.Ordinal); + result = doc.Declaration.ToString() + result.Substring(end + 2); + } + // Keep a final line break the original had + if (text.EndsWith("\n") && !result.EndsWith("\n")) + { + result += settings.NewLineChars; + } + return result; + } + + /// Removes the element and the whitespace before it, so no empty line is left. + private static void RemoveWithIndentation(XElement element) + { + if (element.PreviousNode is XText indentation && string.IsNullOrWhiteSpace(indentation.Value)) + { + indentation.Remove(); + } + element.Remove(); + } + + private static readonly Regex SlnProjectLine = new Regex( + @"^Project\(""(?\{[^}]+\})""\)\s*=\s*""(?[^""]*)""\s*,\s*""(?[^""]*)""\s*,\s*""(?\{[^}]+\})""", + RegexOptions.IgnoreCase); + + /// + /// .sln: removes the Project...EndProject blocks of the companions and every line that names their GUID + /// (configurations, NestedProjects), then the Solution Folder when no project is nested in it anymore. + /// + private static string RemoveFromSln(string text, Func isCompanion) + { + string newLine = text.Contains("\r\n") ? "\r\n" : "\n"; + var lines = text.Split(new[] { newLine }, StringSplitOptions.None).ToList(); + + var companionGuids = new HashSet(StringComparer.OrdinalIgnoreCase); + string folderGuid = null; + foreach (string line in lines) + { + var match = SlnProjectLine.Match(line); + if (!match.Success) + { + continue; + } + if (isCompanion(match.Groups["path"].Value)) + { + companionGuids.Add(match.Groups["guid"].Value); + } + else if (string.Equals(match.Groups["type"].Value, SolutionFolderTypeGuid, StringComparison.OrdinalIgnoreCase) && + match.Groups["name"].Value == SolutionWiring.ShadowDesignerFolderName) + { + folderGuid = match.Groups["guid"].Value; + } + } + if (companionGuids.Count == 0) + { + return null; + } + RemoveSlnProjects(lines, companionGuids); + + // NestedProjects lines read "{child} = {parent}": the folder is empty when it is nobody's parent anymore + if (folderGuid != null && !lines.Any(l => l.Trim().EndsWith("= " + folderGuid, StringComparison.OrdinalIgnoreCase))) + { + RemoveSlnProjects(lines, new HashSet(StringComparer.OrdinalIgnoreCase) { folderGuid }); + } + RemoveEmptyNestedProjectsSection(lines); + return string.Join(newLine, lines); + } + + private static void RemoveSlnProjects(List lines, HashSet guids) + { + for (int i = 0; i < lines.Count; i++) + { + var match = SlnProjectLine.Match(lines[i]); + if (match.Success && guids.Contains(match.Groups["guid"].Value)) + { + int end = i; + while (end < lines.Count && lines[end].Trim() != "EndProject") + { + end++; + } + lines.RemoveRange(i, Math.Min(end, lines.Count - 1) - i + 1); + i--; + } + else if (!match.Success && guids.Any(g => lines[i].TrimStart().StartsWith(g, StringComparison.OrdinalIgnoreCase))) + { + // "{guid}.Debug|Any CPU.ActiveCfg = ..." and "{guid} = {parent}" + lines.RemoveAt(i); + i--; + } + } + } + + private static void RemoveEmptyNestedProjectsSection(List lines) + { + for (int i = 0; i < lines.Count - 1; i++) + { + if (lines[i].Trim().StartsWith("GlobalSection(NestedProjects)", StringComparison.OrdinalIgnoreCase) && + lines[i + 1].Trim() == "EndGlobalSection") + { + lines.RemoveRange(i, 2); + return; + } + } + } + } +} diff --git a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionWiring.cs b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionWiring.cs index 86a201b475..cb64f87a1b 100644 --- a/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionWiring.cs +++ b/src/VisualStudio/ProjectSystemCPS/ShadowDesigner/SolutionWiring.cs @@ -44,11 +44,57 @@ public static void EnsureProjectInSolution(string csprojPath) throw new InvalidOperationException("The solution service does not support adding companion projects."); } + // Adding the companion makes the solution dirty, and so does removing it on close + // (ShadowDesignerCleanup). When nothing else is unsaved, both are saved right away, so the + // companion never makes VS ask to save the solution. + bool wasDirty = IsSolutionDirty(solution); + RemoveStaleHierarchy(solution, csprojPath); RemoveStaleProjectItem(solution, Path.GetFileNameWithoutExtension(csprojPath)); var folder = EnsureSolutionFolder(solution, ShadowDesignerFolderName); ErrorHandler.ThrowOnFailure(solution6.AddExistingProject(csprojPath, folder, out _)); + + if (!wasDirty) + { + SaveSolutionFile(solution, "companion added"); + } + } + + /// True when the solution has changes that are not saved yet. + internal static bool IsSolutionDirty(IVsSolution vsSolution) + { + ThreadHelper.ThrowIfNotOnUIThread(); + return ErrorHandler.Succeeded(vsSolution.GetProperty((int)__VSPROPID.VSPROPID_IsSolutionDirty, out object dirty)) && + dirty is bool isDirty && isDirty; + } + + /// The full path of the solution file, or null for a solution that was never saved. + internal static string GetSolutionFile(IVsSolution vsSolution) + { + ThreadHelper.ThrowIfNotOnUIThread(); + if (ErrorHandler.Failed(vsSolution.GetSolutionInfo(out _, out string solutionFile, out _)) || + string.IsNullOrEmpty(solutionFile) || !File.Exists(solutionFile)) + { + return null; + } + return solutionFile; + } + + /// + /// Saves the solution file without asking. Skipped for a solution that was never saved, where saving + /// would show the Save As dialog. + /// + internal static void SaveSolutionFile(IVsSolution vsSolution, string reason) + { + ThreadHelper.ThrowIfNotOnUIThread(); + string solutionFile = GetSolutionFile(vsSolution); + if (solutionFile == null) + { + return; + } + int hr = vsSolution.SaveSolutionElement((uint)__VSSLNSAVEOPTIONS.SLNSAVEOPT_SaveIfDirty, null, 0); + Logger.Information($"SolutionWiring: saved {solutionFile} ({reason}), hr=0x{hr:X8}"); } ///