From cb12ab93723109ecc3c7da5cc5e58e78da1e7dab Mon Sep 17 00:00:00 2001
From: Siegfried Pammer <siegfriedpammer@gmail.com>
Date: Sun, 26 Apr 2026 17:06:46 +0200
Subject: [PATCH] Persist + restore the selected tree node across launches
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SessionSettings gains an ActiveTreeViewPath (string array) saved every
time AssemblyTreeModel.SelectedItem changes and consulted on the next
launch when the assembly list root is built. To make the path stable
across language switches, each tree node overrides ToString to return a
language-independent identifier — file path for assemblies, ITypeDefinition.
ReflectionName for types, and IL-formatted entity strings for members,
matching the WPF host's scheme.

Assisted-by: Claude:claude-opus-4-7:Claude Code
---
 ILSpy.Tests/SessionSettingsTests.cs          | 15 ++++
 ILSpy/AssemblyTree/AssemblyListPane.axaml    |  3 +-
 ILSpy/AssemblyTree/AssemblyListPane.axaml.cs | 77 +++++++++++++++++++-
 ILSpy/AssemblyTree/AssemblyTreeModel.cs      | 55 ++++++++++++++
 ILSpy/SessionSettings.cs                     | 10 +++
 ILSpy/TreeNodes/AssemblyTreeNode.cs          |  4 +
 ILSpy/TreeNodes/EventTreeNode.cs             |  2 +
 ILSpy/TreeNodes/FieldTreeNode.cs             |  2 +
 ILSpy/TreeNodes/MethodTreeNode.cs            | 10 +++
 ILSpy/TreeNodes/PropertyTreeNode.cs          |  9 +++
 ILSpy/TreeNodes/TypeTreeNode.cs              |  8 ++
 11 files changed, 193 insertions(+), 2 deletions(-)

diff --git a/ILSpy.Tests/SessionSettingsTests.cs b/ILSpy.Tests/SessionSettingsTests.cs
index 45f7a26b6..94ee26235 100644
--- a/ILSpy.Tests/SessionSettingsTests.cs
+++ b/ILSpy.Tests/SessionSettingsTests.cs
@@ -54,4 +54,19 @@ public class SessionSettingsTests
 		loaded.WindowPosition.Should().Be(new PixelPoint(200, 300));
 		loaded.WindowSize.Should().Be(new Size(1024, 768));
 	}
+
+	[Test]
+	public void Save_then_Load_round_trips_ActiveTreeViewPath()
+	{
+		var original = new SessionSettings {
+			ActiveTreeViewPath = ["My.Assembly.dll", "MyNamespace.MyType", "M:MyMethod"],
+		};
+
+		var xml = original.SaveToXml();
+
+		var loaded = new SessionSettings();
+		loaded.LoadFromXml(xml);
+
+		loaded.ActiveTreeViewPath.Should().Equal("My.Assembly.dll", "MyNamespace.MyType", "M:MyMethod");
+	}
 }
diff --git a/ILSpy/AssemblyTree/AssemblyListPane.axaml b/ILSpy/AssemblyTree/AssemblyListPane.axaml
index 64c9e6fd8..c0788f71c 100644
--- a/ILSpy/AssemblyTree/AssemblyListPane.axaml
+++ b/ILSpy/AssemblyTree/AssemblyListPane.axaml
@@ -15,7 +15,8 @@
 	          GridLinesVisibility="None"
 	          IsReadOnly="True"
 	          CanUserResizeColumns="False"
-	          SelectionMode="Single">
+	          SelectionMode="Single"
+	          SelectionChanged="OnTreeGridSelectionChanged">
 		<DataGrid.Columns>
 			<DataGridHierarchicalColumn Header="Name" Width="*"
 			                            x:CompileBindings="False"
diff --git a/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs b/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
index 923351c1b..4ebdc71a1 100644
--- a/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
+++ b/ILSpy/AssemblyTree/AssemblyListPane.axaml.cs
@@ -31,12 +31,72 @@ namespace ILSpy.AssemblyTree
 {
 	public partial class AssemblyListPane : UserControl
 	{
+		// Set while propagating model.SelectedItem → DataGrid.SelectedItem so the resulting
+		// SelectionChanged event doesn't bounce right back into the model.
+		bool syncingSelection;
+
 		public AssemblyListPane()
 		{
 			InitializeComponent();
 			TreeGrid.DoubleTapped += OnTreeGridDoubleTapped;
 		}
 
+		void OnTreeGridSelectionChanged(object? sender, SelectionChangedEventArgs e)
+		{
+			if (syncingSelection || DataContext is not AssemblyTreeModel model)
+				return;
+			SharpTreeNode? selected = null;
+			if (TreeGrid.SelectedItem is HierarchicalNode node && node.Item is SharpTreeNode tree)
+				selected = tree;
+			else if (TreeGrid.SelectedItem is SharpTreeNode direct)
+				selected = direct;
+			if (model.SelectedItem == selected)
+				return;
+			model.SelectedItem = selected;
+		}
+
+		void SyncSelectionFromModel(SharpTreeNode? target)
+		{
+			if (target == null)
+			{
+				if (TreeGrid.SelectedItem != null)
+				{
+					syncingSelection = true;
+					TreeGrid.SelectedItem = null!;
+					syncingSelection = false;
+				}
+				return;
+			}
+			if (TreeGrid.HierarchicalModel is not IHierarchicalModel hm)
+				return;
+
+			// Build the SharpTreeNode path from a root (a child of the hidden AssemblyListTreeNode)
+			// down to the target.
+			var path = new System.Collections.Generic.List<SharpTreeNode>();
+			for (var n = target; n.Parent != null; n = n.Parent)
+				path.Add(n);
+			path.Reverse();
+
+			// Walk top-down: ProDataGrid only materialises children of expanded nodes, so each
+			// ancestor must be expanded before FindNode can locate the next level's wrapper.
+			HierarchicalNode? hNode = null;
+			for (int i = 0; i < path.Count; i++)
+			{
+				hNode = hm.FindNode(path[i]);
+				if (hNode == null)
+					return;
+				if (i < path.Count - 1 && !hNode.IsExpanded)
+					hm.Expand(hNode);
+			}
+
+			if (ReferenceEquals(TreeGrid.SelectedItem, target))
+				return;
+			syncingSelection = true;
+			TreeGrid.SelectedItem = target;
+			syncingSelection = false;
+			TreeGrid.ScrollIntoView(target, TreeGrid.Columns[0]);
+		}
+
 		void OnTreeGridDoubleTapped(object? sender, TappedEventArgs e)
 		{
 			if (TreeGrid.HierarchicalModel is not IHierarchicalModel model)
@@ -59,14 +119,29 @@ namespace ILSpy.AssemblyTree
 			{
 				model.PropertyChanged += Model_PropertyChanged;
 				if (model.Root != null)
+				{
 					BindTree(model.Root);
+					// Push any already-set selection (e.g. one restored from SessionSettings
+					// before the pane subscribed to PropertyChanged) into the DataGrid.
+					if (model.SelectedItem != null)
+						SyncSelectionFromModel(model.SelectedItem);
+				}
 			}
 		}
 
 		void Model_PropertyChanged(object? sender, PropertyChangedEventArgs e)
 		{
-			if (e.PropertyName == nameof(AssemblyTreeModel.Root) && sender is AssemblyTreeModel model && model.Root != null)
+			if (sender is not AssemblyTreeModel model)
+				return;
+			if (e.PropertyName == nameof(AssemblyTreeModel.Root) && model.Root != null)
+			{
 				BindTree(model.Root);
+				SyncSelectionFromModel(model.SelectedItem);
+			}
+			else if (e.PropertyName == nameof(AssemblyTreeModel.SelectedItem))
+			{
+				SyncSelectionFromModel(model.SelectedItem);
+			}
 		}
 
 		void BindTree(SharpTreeNode root)
diff --git a/ILSpy/AssemblyTree/AssemblyTreeModel.cs b/ILSpy/AssemblyTree/AssemblyTreeModel.cs
index a65e69823..c80c7be60 100644
--- a/ILSpy/AssemblyTree/AssemblyTreeModel.cs
+++ b/ILSpy/AssemblyTree/AssemblyTreeModel.cs
@@ -17,8 +17,10 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Composition;
+using System.Linq;
 using System.Runtime.Serialization;
 
 using CommunityToolkit.Mvvm.ComponentModel;
@@ -125,6 +127,59 @@ namespace ILSpy.AssemblyTree
 			Root = new AssemblyListTreeNode(AssemblyList);
 
 			settingsService.SessionSettings.ActiveAssemblyList = value;
+
+			// Restore the previously-selected tree node, if any. Walks the tree by ToString()
+			// matching, materialising lazy children as it goes.
+			var savedPath = settingsService.SessionSettings.ActiveTreeViewPath;
+			if (savedPath is { Length: > 0 })
+			{
+				var restored = FindNodeByPath(savedPath, returnBestMatch: true);
+				if (restored != null && restored != Root)
+					SelectedItem = restored;
+			}
+		}
+
+		partial void OnSelectedItemChanged(SharpTreeNode? value)
+		{
+			settingsService.SessionSettings.ActiveTreeViewPath = GetPathForNode(value);
+		}
+
+		/// <summary>
+		/// Walks down from <see cref="Root"/> matching each path segment against
+		/// <see cref="object.ToString"/>, expanding lazy children along the way.
+		/// </summary>
+		public SharpTreeNode? FindNodeByPath(string[]? path, bool returnBestMatch)
+		{
+			if (path == null || Root == null)
+				return null;
+			SharpTreeNode? node = Root;
+			SharpTreeNode? bestMatch = node;
+			foreach (var element in path)
+			{
+				if (node == null)
+					break;
+				bestMatch = node;
+				node.EnsureLazyChildren();
+				node = node.Children.FirstOrDefault(c => c.ToString() == element);
+			}
+			return returnBestMatch ? node ?? bestMatch : node;
+		}
+
+		/// <summary>
+		/// The path of <paramref name="node"/>'s ancestors (root excluded), in root-first order.
+		/// </summary>
+		public static string[]? GetPathForNode(SharpTreeNode? node)
+		{
+			if (node == null)
+				return null;
+			var path = new List<string>();
+			while (node.Parent != null)
+			{
+				path.Add(node.ToString()!);
+				node = node.Parent;
+			}
+			path.Reverse();
+			return path.ToArray();
 		}
 
 		static void LoadInitialAssemblies(AssemblyList assemblyList)
diff --git a/ILSpy/SessionSettings.cs b/ILSpy/SessionSettings.cs
index c97e66eed..ba5a0c30d 100644
--- a/ILSpy/SessionSettings.cs
+++ b/ILSpy/SessionSettings.cs
@@ -18,6 +18,7 @@
 
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Xml.Linq;
 
 using Avalonia;
@@ -46,6 +47,12 @@ namespace ILSpy
 		[ObservableProperty]
 		private string? activeLanguageName;
 
+		/// <summary>
+		/// Path to the previously-selected tree node (one ToString() per ancestor, root-first).
+		/// Used to restore the selection on the next launch.
+		/// </summary>
+		public string[]? ActiveTreeViewPath { get; set; }
+
 		public WindowState WindowState { get; set; } = WindowState.Normal;
 
 		public PixelPoint WindowPosition { get; set; } = DefaultWindowPosition;
@@ -56,6 +63,7 @@ namespace ILSpy
 		{
 			ActiveAssemblyList = (string?)section.Element("ActiveAssemblyList");
 			ActiveLanguageName = (string?)section.Element("ActiveLanguageName");
+			ActiveTreeViewPath = section.Element("ActiveTreeViewPath")?.Elements().Select(e => (string)e).ToArray();
 			WindowState = ParseEnum(section.Element("WindowState")?.Value, WindowState.Normal);
 
 			var bounds = section.Element("WindowBounds");
@@ -77,6 +85,8 @@ namespace ILSpy
 				section.Add(new XElement("ActiveAssemblyList", ActiveAssemblyList));
 			if (!string.IsNullOrEmpty(ActiveLanguageName))
 				section.Add(new XElement("ActiveLanguageName", ActiveLanguageName));
+			if (ActiveTreeViewPath is { Length: > 0 } path)
+				section.Add(new XElement("ActiveTreeViewPath", path.Select(p => new XElement("Node", p))));
 			section.Add(new XElement("WindowState", WindowState.ToString()));
 			section.Add(new XElement("WindowBounds",
 				new XAttribute("Left", WindowPosition.X.ToString(CultureInfo.InvariantCulture)),
diff --git a/ILSpy/TreeNodes/AssemblyTreeNode.cs b/ILSpy/TreeNodes/AssemblyTreeNode.cs
index 53f86bf7b..cdbd92ca0 100644
--- a/ILSpy/TreeNodes/AssemblyTreeNode.cs
+++ b/ILSpy/TreeNodes/AssemblyTreeNode.cs
@@ -71,6 +71,10 @@ namespace ILSpy.TreeNodes
 
 		public override object Text => assembly.ShortName;
 
+		// ToString is the stable identity used by SessionSettings.ActiveTreeViewPath — must not
+		// depend on the active language. The full file path uniquely identifies the assembly.
+		public override string ToString() => assembly.FileName;
+
 		public override object Icon {
 			get {
 				if (assembly.HasLoadError || loadError != null)
diff --git a/ILSpy/TreeNodes/EventTreeNode.cs b/ILSpy/TreeNodes/EventTreeNode.cs
index c350f69d5..3bd9386c7 100644
--- a/ILSpy/TreeNodes/EventTreeNode.cs
+++ b/ILSpy/TreeNodes/EventTreeNode.cs
@@ -36,5 +36,7 @@ namespace ILSpy.TreeNodes
 		public override object Icon => Images.Images.GetIcon(Images.Images.Event,
 			Images.Images.GetOverlay(EventDefinition.Accessibility), EventDefinition.IsStatic);
 		public override bool ShowExpander => false;
+
+		public override string ToString() => "Event " + EventDefinition.Name;
 	}
 }
diff --git a/ILSpy/TreeNodes/FieldTreeNode.cs b/ILSpy/TreeNodes/FieldTreeNode.cs
index 91fccdf33..2ac6bfe2b 100644
--- a/ILSpy/TreeNodes/FieldTreeNode.cs
+++ b/ILSpy/TreeNodes/FieldTreeNode.cs
@@ -36,5 +36,7 @@ namespace ILSpy.TreeNodes
 		public override object Icon => Images.Images.GetIcon(Images.Images.Field,
 			Images.Images.GetOverlay(FieldDefinition.Accessibility), FieldDefinition.IsStatic);
 		public override bool ShowExpander => false;
+
+		public override string ToString() => "Field " + FieldDefinition.Name;
 	}
 }
diff --git a/ILSpy/TreeNodes/MethodTreeNode.cs b/ILSpy/TreeNodes/MethodTreeNode.cs
index 6234e2b67..8c198d056 100644
--- a/ILSpy/TreeNodes/MethodTreeNode.cs
+++ b/ILSpy/TreeNodes/MethodTreeNode.cs
@@ -47,5 +47,15 @@ namespace ILSpy.TreeNodes
 		}
 
 		public override bool ShowExpander => false;
+
+		// Stable identity for SessionSettings.ActiveTreeViewPath; matches the WPF host's format.
+		public override string ToString()
+			=> "Method " + new ICSharpCode.Decompiler.IL.ILAmbience {
+				ConversionFlags = ConversionFlags.ShowTypeParameterList
+					| ConversionFlags.PlaceReturnTypeAfterParameterList
+					| ConversionFlags.ShowReturnType
+					| ConversionFlags.ShowParameterList
+					| ConversionFlags.ShowParameterModifiers,
+			}.ConvertSymbol(MethodDefinition);
 	}
 }
diff --git a/ILSpy/TreeNodes/PropertyTreeNode.cs b/ILSpy/TreeNodes/PropertyTreeNode.cs
index 1864facbf..7f2cc6759 100644
--- a/ILSpy/TreeNodes/PropertyTreeNode.cs
+++ b/ILSpy/TreeNodes/PropertyTreeNode.cs
@@ -36,5 +36,14 @@ namespace ILSpy.TreeNodes
 		public override object Icon => Images.Images.GetIcon(Images.Images.Property,
 			Images.Images.GetOverlay(PropertyDefinition.Accessibility), PropertyDefinition.IsStatic);
 		public override bool ShowExpander => false;
+
+		public override string ToString()
+			=> "Property " + new ICSharpCode.Decompiler.IL.ILAmbience {
+				ConversionFlags = ConversionFlags.ShowTypeParameterList
+					| ConversionFlags.PlaceReturnTypeAfterParameterList
+					| ConversionFlags.ShowReturnType
+					| ConversionFlags.ShowParameterList
+					| ConversionFlags.ShowParameterModifiers,
+			}.ConvertSymbol(PropertyDefinition);
 	}
 }
diff --git a/ILSpy/TreeNodes/TypeTreeNode.cs b/ILSpy/TreeNodes/TypeTreeNode.cs
index 545d1744a..6a4b4a616 100644
--- a/ILSpy/TreeNodes/TypeTreeNode.cs
+++ b/ILSpy/TreeNodes/TypeTreeNode.cs
@@ -71,6 +71,14 @@ namespace ILSpy.TreeNodes
 
 		public override bool CanExpandRecursively => true;
 
+		// Stable identity for SessionSettings.ActiveTreeViewPath. ReflectionName is
+		// language-independent.
+		public override string ToString()
+		{
+			var typeDef = ResolveTypeDefinition();
+			return typeDef?.ReflectionName ?? module.Metadata.GetString(module.Metadata.GetTypeDefinition(handle).Name);
+		}
+
 		ITypeDefinition? ResolveTypeDefinition()
 		{
 			var typeSystem = module.GetTypeSystemOrNull();