Fix #3521: Add API to set an initially highlighted entity after navigation.

siegfriedpammer · siegfriedpammer · commit eb4a80d1fcb4 · 2025-09-04T11:49:47.000+02:00
diff --git a/ICSharpCode.Decompiler/Output/ITextOutput.cs b/ICSharpCode.Decompiler/Output/ITextOutput.cs
@@ -41,6 +41,8 @@ public interface ITextOutput
 
 		void MarkFoldStart(string collapsedText = "...", bool defaultCollapsed = false, bool isDefinition = false);
 		void MarkFoldEnd();
+
+		void SetInitialHighlight(object reference);
 	}
 
 	public static class TextOutputExtensions
diff --git a/ICSharpCode.Decompiler/Output/PlainTextOutput.cs b/ICSharpCode.Decompiler/Output/PlainTextOutput.cs
@@ -150,6 +150,11 @@ void ITextOutput.MarkFoldStart(string collapsedText, bool defaultCollapsed, bool
 		void ITextOutput.MarkFoldEnd()
 		{
 		}
+
+		void ITextOutput.SetInitialHighlight(object reference)
+		{
+			throw new NotImplementedException();
+		}
 	}
 
 	internal class TextOutputWithRollback : ITextOutput
@@ -239,5 +244,10 @@ public void WriteReference(IMember member, string text, bool isDefinition = fals
 		{
 			actions.Add(target => target.WriteReference(member, text, isDefinition));
 		}
+
+		public void SetInitialHighlight(object reference)
+		{
+			actions.Add(target => target.SetInitialHighlight(reference));
+		}
 	}
 }
diff --git a/ILSpy/Analyzers/AnalyzerEntityTreeNode.cs b/ILSpy/Analyzers/AnalyzerEntityTreeNode.cs
@@ -17,6 +17,7 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Windows;
 
 using ICSharpCode.Decompiler.TypeSystem;
@@ -25,6 +26,8 @@
 using ICSharpCode.ILSpyX.TreeView;
 using ICSharpCode.ILSpyX.TreeView.PlatformAbstractions;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers
 {
 	/// <summary>
@@ -34,6 +37,8 @@ public abstract class AnalyzerEntityTreeNode : AnalyzerTreeNode, IMemberTreeNode
 	{
 		public abstract IEntity Member { get; }
 
+		public IEntity? SourceMember { get; protected set; }
+
 		public override void ActivateItem(IPlatformRoutedEventArgs e)
 		{
 			e.Handled = true;
@@ -43,10 +48,14 @@ public override void ActivateItem(IPlatformRoutedEventArgs e)
 				return;
 			}
 
-			MessageBus.Send(this, new NavigateToReferenceEventArgs(new EntityReference(this.Member.ParentModule?.MetadataFile, this.Member.MetadataToken)));
+			var module = this.Member.ParentModule?.MetadataFile;
+
+			Debug.Assert(module != null);
+
+			MessageBus.Send(this, new NavigateToReferenceEventArgs(new EntityReference(module, this.Member.MetadataToken), this.SourceMember));
 		}
 
-		public override object ToolTip => Member?.ParentModule?.MetadataFile?.FileName;
+		public override object? ToolTip => Member?.ParentModule?.MetadataFile?.FileName;
 
 		public override bool HandleAssemblyListChanged(ICollection<LoadedAssembly> removedAssemblies, ICollection<LoadedAssembly> addedAssemblies)
 		{
diff --git a/ILSpy/Analyzers/AnalyzerSearchTreeNode.cs b/ILSpy/Analyzers/AnalyzerSearchTreeNode.cs
@@ -76,29 +76,29 @@ protected IEnumerable<AnalyzerTreeNode> FetchChildren(CancellationToken ct)
 			}
 		}
 
-		AnalyzerTreeNode SymbolTreeNodeFactory(ISymbol symbol)
+		AnalyzerTreeNode SymbolTreeNodeFactory(ISymbol resultSymbol)
 		{
-			if (symbol == null)
+			if (resultSymbol == null)
 			{
-				throw new ArgumentNullException(nameof(symbol));
+				throw new ArgumentNullException(nameof(resultSymbol));
 			}
 
-			switch (symbol)
+			switch (resultSymbol)
 			{
 				case IModule module:
-					return new AnalyzedModuleTreeNode(module) { };
+					return new AnalyzedModuleTreeNode(module, (IEntity)this.symbol);
 				case ITypeDefinition td:
-					return new AnalyzedTypeTreeNode(td) { };
+					return new AnalyzedTypeTreeNode(td, (IEntity)this.symbol);
 				case IField fd:
-					return new AnalyzedFieldTreeNode(fd) { };
+					return new AnalyzedFieldTreeNode(fd, (IEntity)this.symbol);
 				case IMethod md:
-					return new AnalyzedMethodTreeNode(md) { };
+					return new AnalyzedMethodTreeNode(md, (IEntity)this.symbol);
 				case IProperty pd:
-					return new AnalyzedPropertyTreeNode(pd) { };
+					return new AnalyzedPropertyTreeNode(pd, (IEntity)this.symbol);
 				case IEvent ed:
-					return new AnalyzedEventTreeNode(ed) { };
+					return new AnalyzedEventTreeNode(ed, (IEntity)this.symbol);
 				default:
-					throw new ArgumentOutOfRangeException(nameof(symbol), $"Symbol {symbol.GetType().FullName} is not supported.");
+					throw new ArgumentOutOfRangeException(nameof(resultSymbol), $"Symbol {resultSymbol.GetType().FullName} is not supported.");
 			}
 		}
 
diff --git a/ILSpy/Analyzers/AnalyzerTreeViewModel.cs b/ILSpy/Analyzers/AnalyzerTreeViewModel.cs
@@ -109,20 +109,20 @@ public void Analyze(IEntity entity)
 			switch (entity)
 			{
 				case ITypeDefinition td:
-					AddOrSelect(new AnalyzedTypeTreeNode(td));
+					AddOrSelect(new AnalyzedTypeTreeNode(td, null));
 					break;
 				case IField fd:
 					if (!fd.IsConst)
-						AddOrSelect(new AnalyzedFieldTreeNode(fd));
+						AddOrSelect(new AnalyzedFieldTreeNode(fd, null));
 					break;
 				case IMethod md:
-					AddOrSelect(new AnalyzedMethodTreeNode(md));
+					AddOrSelect(new AnalyzedMethodTreeNode(md, null));
 					break;
 				case IProperty pd:
-					AddOrSelect(new AnalyzedPropertyTreeNode(pd));
+					AddOrSelect(new AnalyzedPropertyTreeNode(pd, null));
 					break;
 				case IEvent ed:
-					AddOrSelect(new AnalyzedEventTreeNode(ed));
+					AddOrSelect(new AnalyzedEventTreeNode(ed, null));
 					break;
 				default:
 					throw new ArgumentOutOfRangeException(nameof(entity), $@"Entity {entity.GetType().FullName} is not supported.");
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedAccessorTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedAccessorTreeNode.cs
@@ -24,8 +24,8 @@ class AnalyzedAccessorTreeNode : AnalyzedMethodTreeNode
 	{
 		readonly string name;
 
-		public AnalyzedAccessorTreeNode(IMethod analyzedMethod, string name)
-			: base(analyzedMethod)
+		public AnalyzedAccessorTreeNode(IMethod analyzedMethod, IEntity source, string name)
+			: base(analyzedMethod, source)
 		{
 			if (string.IsNullOrWhiteSpace(name))
 			{
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedEventTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedEventTreeNode.cs
@@ -21,18 +21,21 @@
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.TreeNodes;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal sealed class AnalyzedEventTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly IEvent analyzedEvent;
 		readonly string prefix;
 
-		public AnalyzedEventTreeNode(IEvent analyzedEvent, string prefix = "")
+		public AnalyzedEventTreeNode(IEvent analyzedEvent, IEntity? source, string prefix = "")
 		{
 			this.analyzedEvent = analyzedEvent ?? throw new ArgumentNullException(nameof(analyzedEvent));
 			this.prefix = prefix;
 			this.LazyLoading = true;
+			this.SourceMember = source;
 		}
 
 		public override IEntity Member => analyzedEvent;
@@ -45,11 +48,11 @@ public AnalyzedEventTreeNode(IEvent analyzedEvent, string prefix = "")
 		protected override void LoadChildren()
 		{
 			if (analyzedEvent.CanAdd)
-				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.AddAccessor, "add"));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.AddAccessor, this.SourceMember, "add"));
 			if (analyzedEvent.CanRemove)
-				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.RemoveAccessor, "remove"));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.RemoveAccessor, this.SourceMember, "remove"));
 			if (TryFindBackingField(analyzedEvent, out var backingField))
-				this.Children.Add(new AnalyzedFieldTreeNode(backingField));
+				this.Children.Add(new AnalyzedFieldTreeNode(backingField, this.SourceMember));
 
 			foreach (var lazy in Analyzers)
 			{
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedFieldTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedFieldTreeNode.cs
@@ -21,15 +21,18 @@
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.TreeNodes;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	class AnalyzedFieldTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly IField analyzedField;
 
-		public AnalyzedFieldTreeNode(IField analyzedField)
+		public AnalyzedFieldTreeNode(IField analyzedField, IEntity? source)
 		{
 			this.analyzedField = analyzedField ?? throw new ArgumentNullException(nameof(analyzedField));
+			this.SourceMember = source;
 			this.LazyLoading = true;
 		}
 
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedMethodTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedMethodTreeNode.cs
@@ -21,16 +21,19 @@
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.TreeNodes;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal class AnalyzedMethodTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly IMethod analyzedMethod;
 		readonly string prefix;
 
-		public AnalyzedMethodTreeNode(IMethod analyzedMethod, string prefix = "")
+		public AnalyzedMethodTreeNode(IMethod analyzedMethod, IEntity? source, string prefix = "")
 		{
 			this.analyzedMethod = analyzedMethod ?? throw new ArgumentNullException(nameof(analyzedMethod));
+			this.SourceMember = source;
 			this.prefix = prefix;
 			this.LazyLoading = true;
 		}
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedModuleTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedModuleTreeNode.cs
@@ -25,15 +25,18 @@
 using ICSharpCode.ILSpyX.TreeView;
 using ICSharpCode.ILSpyX.TreeView.PlatformAbstractions;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal class AnalyzedModuleTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly IModule analyzedModule;
 
-		public AnalyzedModuleTreeNode(IModule analyzedModule)
+		public AnalyzedModuleTreeNode(IModule analyzedModule, IEntity? source)
 		{
 			this.analyzedModule = analyzedModule ?? throw new ArgumentNullException(nameof(analyzedModule));
+			this.SourceMember = source;
 			this.LazyLoading = true;
 		}
 
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedPropertyTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedPropertyTreeNode.cs
@@ -21,18 +21,21 @@
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.TreeNodes;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	sealed class AnalyzedPropertyTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly IProperty analyzedProperty;
 		readonly string prefix;
 
-		public AnalyzedPropertyTreeNode(IProperty analyzedProperty, string prefix = "")
+		public AnalyzedPropertyTreeNode(IProperty analyzedProperty, IEntity? source, string prefix = "")
 		{
 			this.analyzedProperty = analyzedProperty ?? throw new ArgumentNullException(nameof(analyzedProperty));
 			this.prefix = prefix;
 			this.LazyLoading = true;
+			this.SourceMember = source;
 		}
 
 		public override object Icon => PropertyTreeNode.GetIcon(analyzedProperty);
@@ -43,9 +46,9 @@ public AnalyzedPropertyTreeNode(IProperty analyzedProperty, string prefix = "")
 		protected override void LoadChildren()
 		{
 			if (analyzedProperty.CanGet)
-				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Getter, "get"));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Getter, this.SourceMember, "get"));
 			if (analyzedProperty.CanSet)
-				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Setter, "set"));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Setter, this.SourceMember, "set"));
 
 			foreach (var lazy in Analyzers)
 			{
diff --git a/ILSpy/Analyzers/TreeNodes/AnalyzedTypeTreeNode.cs b/ILSpy/Analyzers/TreeNodes/AnalyzedTypeTreeNode.cs
@@ -21,15 +21,18 @@
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.TreeNodes;
 
+#nullable enable
+
 namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal class AnalyzedTypeTreeNode : AnalyzerEntityTreeNode
 	{
 		readonly ITypeDefinition analyzedType;
 
-		public AnalyzedTypeTreeNode(ITypeDefinition analyzedType)
+		public AnalyzedTypeTreeNode(ITypeDefinition analyzedType, IEntity? source)
 		{
 			this.analyzedType = analyzedType ?? throw new ArgumentNullException(nameof(analyzedType));
+			this.SourceMember = source;
 			this.LazyLoading = true;
 		}
 
diff --git a/ILSpy/AssemblyTree/AssemblyTreeModel.cs b/ILSpy/AssemblyTree/AssemblyTreeModel.cs
@@ -67,6 +67,7 @@ public class AssemblyTreeModel : ToolPaneModel
 
 		private readonly NavigationHistory<NavigationState> history = new();
 		private NavigationState? navigatingToState;
+		private object? sourceOfReference;
 		private readonly SettingsService settingsService;
 		private readonly LanguageService languageService;
 		private readonly IExportProvider exportProvider;
@@ -262,7 +263,7 @@ private async Task NavigateOnLaunch(string? navigateTo, string[]? activeTreeView
 						found = true;
 						if (SelectedItem == initialSelection)
 						{
-							await JumpToReferenceAsync(mr);
+							await JumpToReferenceAsync(mr, null);
 						}
 					}
 				}
@@ -642,7 +643,7 @@ public void SelectNodes(IEnumerable<SharpTreeNode> nodes)
 
 		private void JumpToReference(object? sender, NavigateToReferenceEventArgs e)
 		{
-			JumpToReferenceAsync(e.Reference, e.InNewTabPage).HandleExceptions();
+			JumpToReferenceAsync(e.Reference, e.Source, e.InNewTabPage).HandleExceptions();
 			IsActive = true;
 		}
 
@@ -653,8 +654,9 @@ private void JumpToReference(object? sender, NavigateToReferenceEventArgs e)
 		/// Returns a task that will signal completion when the decompilation of the jump target has finished.
 		/// The task will be marked as canceled if the decompilation is canceled.
 		/// </returns>
-		private Task JumpToReferenceAsync(object? reference, bool inNewTabPage = false)
+		private Task JumpToReferenceAsync(object? reference, object? source, bool inNewTabPage = false)
 		{
+			this.sourceOfReference = source;
 			var decompilationTask = Task.CompletedTask;
 
 			switch (reference)
@@ -804,6 +806,8 @@ void ContextMenuClosed(object? sender, EventArgs e)
 
 		public void DecompileSelectedNodes(ViewState? newState = null)
 		{
+			object? source = this.sourceOfReference;
+			this.sourceOfReference = null;
 			var activeTabPage = DockWorkspace.ActiveTabPage;
 
 			if (activeTabPage.FrozenContent)
@@ -831,7 +835,9 @@ public void DecompileSelectedNodes(ViewState? newState = null)
 
 			var options = activeTabPage.CreateDecompilationOptions();
 			options.TextViewState = newState as DecompilerTextViewState;
-			activeTabPage.ShowTextViewAsync(textView => textView.DecompileAsync(this.CurrentLanguage, this.SelectedNodes, options));
+			activeTabPage.ShowTextViewAsync(textView => {
+				return textView.DecompileAsync(this.CurrentLanguage, this.SelectedNodes, source, options);
+			});
 		}
 
 		public void RefreshDecompiledView()
diff --git a/ILSpy/TextView/AvalonEditTextOutput.cs b/ILSpy/TextView/AvalonEditTextOutput.cs
@@ -312,6 +312,13 @@ public void WriteLocalReference(string text, object reference, bool isDefinition
 			references.Add(new ReferenceSegment { StartOffset = start, EndOffset = end, Reference = reference, IsLocal = true, IsDefinition = isDefinition });
 		}
 
+		internal object InitialHighlightReference = null;
+
+		public void SetInitialHighlight(object reference)
+		{
+			this.InitialHighlightReference = reference;
+		}
+
 		public void MarkFoldStart(string collapsedText = "...", bool defaultCollapsed = false, bool isDefinition = false)
 		{
 			WriteIndent();
diff --git a/ILSpy/TextView/DecompilerTextView.cs b/ILSpy/TextView/DecompilerTextView.cs
diff --git a/ILSpy/Util/MessageBus.cs b/ILSpy/Util/MessageBus.cs
diff --git a/ILSpy/Views/DebugSteps.xaml.cs b/ILSpy/Views/DebugSteps.xaml.cs

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,8 @@ public interface ITextOutput`
`41`	`41`
`42`	`42`	`void MarkFoldStart(string collapsedText = "...", bool defaultCollapsed = false, bool isDefinition = false);`
`43`	`43`	`void MarkFoldEnd();`
	`44`	`+`
	`45`	`+ void SetInitialHighlight(object reference);`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`public static class TextOutputExtensions`
Original file line number	Diff line number	Diff line change
`@@ -150,6 +150,11 @@ void ITextOutput.MarkFoldStart(string collapsedText, bool defaultCollapsed, bool`
`150`	`150`	`void ITextOutput.MarkFoldEnd()`
`151`	`151`	`{`
`152`	`152`	`}`
	`153`	`+`
	`154`	`+ void ITextOutput.SetInitialHighlight(object reference)`
	`155`	`+ {`
	`156`	`+ throw new NotImplementedException();`
	`157`	`+ }`
`153`	`158`	`}`
`154`	`159`
`155`	`160`	`internal class TextOutputWithRollback : ITextOutput`
`@@ -239,5 +244,10 @@ public void WriteReference(IMember member, string text, bool isDefinition = fals`
`239`	`244`	`{`
`240`	`245`	`actions.Add(target => target.WriteReference(member, text, isDefinition));`
`241`	`246`	`}`
	`247`	`+`
	`248`	`+ public void SetInitialHighlight(object reference)`
	`249`	`+ {`
	`250`	`+ actions.Add(target => target.SetInitialHighlight(reference));`
	`251`	`+ }`
`242`	`252`	`}`
`243`	`253`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`	`// DEALINGS IN THE SOFTWARE.`
`18`	`18`
`19`	`19`	`using System.Collections.Generic;`
	`20`	`+using System.Diagnostics;`
`20`	`21`	`using System.Windows;`
`21`	`22`
`22`	`23`	`using ICSharpCode.Decompiler.TypeSystem;`
`@@ -25,6 +26,8 @@`
`25`	`26`	`using ICSharpCode.ILSpyX.TreeView;`
`26`	`27`	`using ICSharpCode.ILSpyX.TreeView.PlatformAbstractions;`
`27`	`28`
	`29`	`+#nullable enable`
	`30`	`+`
`28`	`31`	`namespace ICSharpCode.ILSpy.Analyzers`
`29`	`32`	`{`
`30`	`33`	`/// <summary>`
`@@ -34,6 +37,8 @@ public abstract class AnalyzerEntityTreeNode : AnalyzerTreeNode, IMemberTreeNode`
`34`	`37`	`{`
`35`	`38`	`public abstract IEntity Member { get; }`
`36`	`39`
	`40`	`+ public IEntity? SourceMember { get; protected set; }`
	`41`	`+`
`37`	`42`	`public override void ActivateItem(IPlatformRoutedEventArgs e)`
`38`	`43`	`{`
`39`	`44`	`e.Handled = true;`
`@@ -43,10 +48,14 @@ public override void ActivateItem(IPlatformRoutedEventArgs e)`
`43`	`48`	`return;`
`44`	`49`	`}`
`45`	`50`
`46`		`- MessageBus.Send(this, new NavigateToReferenceEventArgs(new EntityReference(this.Member.ParentModule?.MetadataFile, this.Member.MetadataToken)));`
	`51`	`+ var module = this.Member.ParentModule?.MetadataFile;`
	`52`	`+`
	`53`	`+ Debug.Assert(module != null);`
	`54`	`+`
	`55`	`+ MessageBus.Send(this, new NavigateToReferenceEventArgs(new EntityReference(module, this.Member.MetadataToken), this.SourceMember));`
`47`	`56`	`}`
`48`	`57`
`49`		`- public override object ToolTip => Member?.ParentModule?.MetadataFile?.FileName;`
	`58`	`+ public override object? ToolTip => Member?.ParentModule?.MetadataFile?.FileName;`
`50`	`59`
`51`	`60`	`public override bool HandleAssemblyListChanged(ICollection<LoadedAssembly> removedAssemblies, ICollection<LoadedAssembly> addedAssemblies)`
`52`	`61`	`{`
Original file line number	Diff line number	Diff line change
`@@ -76,29 +76,29 @@ protected IEnumerable<AnalyzerTreeNode> FetchChildren(CancellationToken ct)`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`		`- AnalyzerTreeNode SymbolTreeNodeFactory(ISymbol symbol)`
	`79`	`+ AnalyzerTreeNode SymbolTreeNodeFactory(ISymbol resultSymbol)`
`80`	`80`	`{`
`81`		`- if (symbol == null)`
	`81`	`+ if (resultSymbol == null)`
`82`	`82`	`{`
`83`		`- throw new ArgumentNullException(nameof(symbol));`
	`83`	`+ throw new ArgumentNullException(nameof(resultSymbol));`
`84`	`84`	`}`
`85`	`85`
`86`		`- switch (symbol)`
	`86`	`+ switch (resultSymbol)`
`87`	`87`	`{`
`88`	`88`	`case IModule module:`
`89`		`- return new AnalyzedModuleTreeNode(module) { };`
	`89`	`+ return new AnalyzedModuleTreeNode(module, (IEntity)this.symbol);`
`90`	`90`	`case ITypeDefinition td:`
`91`		`- return new AnalyzedTypeTreeNode(td) { };`
	`91`	`+ return new AnalyzedTypeTreeNode(td, (IEntity)this.symbol);`
`92`	`92`	`case IField fd:`
`93`		`- return new AnalyzedFieldTreeNode(fd) { };`
	`93`	`+ return new AnalyzedFieldTreeNode(fd, (IEntity)this.symbol);`
`94`	`94`	`case IMethod md:`
`95`		`- return new AnalyzedMethodTreeNode(md) { };`
	`95`	`+ return new AnalyzedMethodTreeNode(md, (IEntity)this.symbol);`
`96`	`96`	`case IProperty pd:`
`97`		`- return new AnalyzedPropertyTreeNode(pd) { };`
	`97`	`+ return new AnalyzedPropertyTreeNode(pd, (IEntity)this.symbol);`
`98`	`98`	`case IEvent ed:`
`99`		`- return new AnalyzedEventTreeNode(ed) { };`
	`99`	`+ return new AnalyzedEventTreeNode(ed, (IEntity)this.symbol);`
`100`	`100`	`default:`
`101`		`- throw new ArgumentOutOfRangeException(nameof(symbol), $"Symbol {symbol.GetType().FullName} is not supported.");`
	`101`	`+ throw new ArgumentOutOfRangeException(nameof(resultSymbol), $"Symbol {resultSymbol.GetType().FullName} is not supported.");`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ class AnalyzedAccessorTreeNode : AnalyzedMethodTreeNode`
`24`	`24`	`{`
`25`	`25`	`readonly string name;`
`26`	`26`
`27`		`- public AnalyzedAccessorTreeNode(IMethod analyzedMethod, string name)`
`28`		`- : base(analyzedMethod)`
	`27`	`+ public AnalyzedAccessorTreeNode(IMethod analyzedMethod, IEntity source, string name)`
	`28`	`+ : base(analyzedMethod, source)`
`29`	`29`	`{`
`30`	`30`	`if (string.IsNullOrWhiteSpace(name))`
`31`	`31`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,18 +21,21 @@`
`21`	`21`	`using ICSharpCode.Decompiler.TypeSystem;`
`22`	`22`	`using ICSharpCode.ILSpy.TreeNodes;`
`23`	`23`
	`24`	`+#nullable enable`
	`25`	`+`
`24`	`26`	`namespace ICSharpCode.ILSpy.Analyzers.TreeNodes`
`25`	`27`	`{`
`26`	`28`	`internal sealed class AnalyzedEventTreeNode : AnalyzerEntityTreeNode`
`27`	`29`	`{`
`28`	`30`	`readonly IEvent analyzedEvent;`
`29`	`31`	`readonly string prefix;`
`30`	`32`
`31`		`- public AnalyzedEventTreeNode(IEvent analyzedEvent, string prefix = "")`
	`33`	`+ public AnalyzedEventTreeNode(IEvent analyzedEvent, IEntity? source, string prefix = "")`
`32`	`34`	`{`
`33`	`35`	`this.analyzedEvent = analyzedEvent ?? throw new ArgumentNullException(nameof(analyzedEvent));`
`34`	`36`	`this.prefix = prefix;`
`35`	`37`	`this.LazyLoading = true;`
	`38`	`+ this.SourceMember = source;`
`36`	`39`	`}`
`37`	`40`
`38`	`41`	`public override IEntity Member => analyzedEvent;`
`@@ -45,11 +48,11 @@ public AnalyzedEventTreeNode(IEvent analyzedEvent, string prefix = "")`
`45`	`48`	`protected override void LoadChildren()`
`46`	`49`	`{`
`47`	`50`	`if (analyzedEvent.CanAdd)`
`48`		`- this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.AddAccessor, "add"));`
	`51`	`+ this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.AddAccessor, this.SourceMember, "add"));`
`49`	`52`	`if (analyzedEvent.CanRemove)`
`50`		`- this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.RemoveAccessor, "remove"));`
	`53`	`+ this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.RemoveAccessor, this.SourceMember, "remove"));`
`51`	`54`	`if (TryFindBackingField(analyzedEvent, out var backingField))`
`52`		`- this.Children.Add(new AnalyzedFieldTreeNode(backingField));`
	`55`	`+ this.Children.Add(new AnalyzedFieldTreeNode(backingField, this.SourceMember));`
`53`	`56`
`54`	`57`	`foreach (var lazy in Analyzers)`
`55`	`58`	`{`
Original file line number	Diff line number	Diff line change
`@@ -21,15 +21,18 @@`
`21`	`21`	`using ICSharpCode.Decompiler.TypeSystem;`
`22`	`22`	`using ICSharpCode.ILSpy.TreeNodes;`
`23`	`23`
	`24`	`+#nullable enable`
	`25`	`+`
`24`	`26`	`namespace ICSharpCode.ILSpy.Analyzers.TreeNodes`
`25`	`27`	`{`
`26`	`28`	`class AnalyzedFieldTreeNode : AnalyzerEntityTreeNode`
`27`	`29`	`{`
`28`	`30`	`readonly IField analyzedField;`
`29`	`31`
`30`		`- public AnalyzedFieldTreeNode(IField analyzedField)`
	`32`	`+ public AnalyzedFieldTreeNode(IField analyzedField, IEntity? source)`
`31`	`33`	`{`
`32`	`34`	`this.analyzedField = analyzedField ?? throw new ArgumentNullException(nameof(analyzedField));`
	`35`	`+ this.SourceMember = source;`
`33`	`36`	`this.LazyLoading = true;`
`34`	`37`	`}`
`35`	`38`
Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,19 @@`
`21`	`21`	`using ICSharpCode.Decompiler.TypeSystem;`
`22`	`22`	`using ICSharpCode.ILSpy.TreeNodes;`
`23`	`23`
	`24`	`+#nullable enable`
	`25`	`+`
`24`	`26`	`namespace ICSharpCode.ILSpy.Analyzers.TreeNodes`
`25`	`27`	`{`
`26`	`28`	`internal class AnalyzedMethodTreeNode : AnalyzerEntityTreeNode`
`27`	`29`	`{`
`28`	`30`	`readonly IMethod analyzedMethod;`
`29`	`31`	`readonly string prefix;`
`30`	`32`
`31`		`- public AnalyzedMethodTreeNode(IMethod analyzedMethod, string prefix = "")`
	`33`	`+ public AnalyzedMethodTreeNode(IMethod analyzedMethod, IEntity? source, string prefix = "")`
`32`	`34`	`{`
`33`	`35`	`this.analyzedMethod = analyzedMethod ?? throw new ArgumentNullException(nameof(analyzedMethod));`
	`36`	`+ this.SourceMember = source;`
`34`	`37`	`this.prefix = prefix;`
`35`	`38`	`this.LazyLoading = true;`
`36`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,15 +25,18 @@`
`25`	`25`	`using ICSharpCode.ILSpyX.TreeView;`
`26`	`26`	`using ICSharpCode.ILSpyX.TreeView.PlatformAbstractions;`
`27`	`27`
	`28`	`+#nullable enable`
	`29`	`+`
`28`	`30`	`namespace ICSharpCode.ILSpy.Analyzers.TreeNodes`
`29`	`31`	`{`
`30`	`32`	`internal class AnalyzedModuleTreeNode : AnalyzerEntityTreeNode`
`31`	`33`	`{`
`32`	`34`	`readonly IModule analyzedModule;`
`33`	`35`
`34`		`- public AnalyzedModuleTreeNode(IModule analyzedModule)`
	`36`	`+ public AnalyzedModuleTreeNode(IModule analyzedModule, IEntity? source)`
`35`	`37`	`{`
`36`	`38`	`this.analyzedModule = analyzedModule ?? throw new ArgumentNullException(nameof(analyzedModule));`
	`39`	`+ this.SourceMember = source;`
`37`	`40`	`this.LazyLoading = true;`
`38`	`41`	`}`
`39`	`42`