Clean Analyzer tree nodes

ILSpy/Analyzers/TreeNodes/AnalyzedEventTreeNode.cs

@@ -18,72 +18,47 @@
 
 using System;
 using System.Linq;
-using System.Reflection.Metadata;
+using ICSharpCode.Decompiler.TypeSystem;
+using ICSharpCode.ILSpy.TreeNodes;
 
-namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal sealed class AnalyzedEventTreeNode : AnalyzerEntityTreeNode
 	{
-		readonly Decompiler.Metadata.PEFile module;
+		readonly IEvent analyzedEvent;
-		readonly EventDefinitionHandle analyzedEvent;
 		readonly string prefix;
 
-		public AnalyzedEventTreeNode(Decompiler.Metadata.PEFile module, EventDefinitionHandle analyzedEvent, string prefix = "")
+		public AnalyzedEventTreeNode(IEvent analyzedEvent, string prefix = "")
 		{
-			if (analyzedEvent == null)
+			this.analyzedEvent = analyzedEvent ?? throw new ArgumentNullException(nameof(analyzedEvent));
-				throw new ArgumentNullException(nameof(analyzedEvent));
-			this.module = module;
-			this.analyzedEvent = analyzedEvent;
 			this.prefix = prefix;
 			this.LazyLoading = true;
 		}
 
-		public override Decompiler.Metadata.IMetadataEntity Member => new Decompiler.Metadata.EventDefinition(module, analyzedEvent);
+		public override IEntity Member => analyzedEvent;
 
-		public override object Icon
+		public override object Icon => EventTreeNode.GetIcon(analyzedEvent);
-		{
-			get { return EventTreeNode.GetIcon(new Decompiler.Metadata.EventDefinition(module, analyzedEvent)); }
-		}
 
 		// TODO: This way of formatting is not suitable for events which explicitly implement interfaces.
-		public override object Text => prefix + Language.EventToString(new Decompiler.Metadata.EventDefinition(module, analyzedEvent), includeTypeName: true, includeNamespace: true);
+		public override object Text => prefix + Language.EventToString(analyzedEvent, includeTypeName: true, includeNamespace: true);
 
 		protected override void LoadChildren()
 		{
-			if (analyzedEvent.AddMethod != null)
+			if (analyzedEvent.AddAccessor != null)
-				this.Children.Add(new AnalyzedEventAccessorTreeNode(analyzedEvent.AddMethod, "add"));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.AddAccessor, "add"));
-			
-			if (analyzedEvent.RemoveMethod != null)
-				this.Children.Add(new AnalyzedEventAccessorTreeNode(analyzedEvent.RemoveMethod, "remove"));
-			
-			foreach (var accessor in analyzedEvent.OtherMethods)
-				this.Children.Add(new AnalyzedEventAccessorTreeNode(accessor, null));
-
-			if (AnalyzedEventFiredByTreeNode.CanShow(analyzedEvent))
-				this.Children.Add(new AnalyzedEventFiredByTreeNode(analyzedEvent));
 			
-			if (AnalyzedEventOverridesTreeNode.CanShow(analyzedEvent))
+			if (analyzedEvent.RemoveAccessor != null)
-				this.Children.Add(new AnalyzedEventOverridesTreeNode(analyzedEvent));
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedEvent.RemoveAccessor, "remove"));
 
-			if (AnalyzedInterfaceEventImplementedByTreeNode.CanShow(analyzedEvent))
+			//foreach (var accessor in analyzedEvent.OtherMethods)
-				this.Children.Add(new AnalyzedInterfaceEventImplementedByTreeNode(analyzedEvent));
+			//	this.Children.Add(new AnalyzedAccessorTreeNode(accessor, null));
-		}
 
-		/*public static AnalyzerTreeNode TryCreateAnalyzer(MemberReference member)
+			foreach (var lazy in App.ExportProvider.GetExports<IAnalyzer<IEvent>>()) {
-		{
+				var analyzer = lazy.Value;
-			if (CanShow(member))
+				if (analyzer.Show(analyzedEvent)) {
-				return new AnalyzedEventTreeNode(member as EventDefinition);
+					this.Children.Add(new AnalyzerSearchTreeNode<IEvent>(analyzedEvent, analyzer));
-			else
+				}
-				return null;
+			}
 		}
-
-		public static bool CanShow(IMemberReference member)
-		{
-			if (!(member is EventDefinition eventDef))
-				return false;
-
-			return !MainWindow.Instance.CurrentLanguage.ShowMember(eventDef.GetAccessors().First().Method)
-				|| AnalyzedEventOverridesTreeNode.CanShow(eventDef);
-		}*/
 	}
 }

ILSpy/Analyzers/TreeNodes/AnalyzedFieldTreeNode.cs

@@ -17,12 +17,10 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
-using System.Reflection.Metadata;
-using ICSharpCode.Decompiler;
 using ICSharpCode.Decompiler.TypeSystem;
-using ICSharpCode.ILSpy.Analyzers;
+using ICSharpCode.ILSpy.TreeNodes;
 
-namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	class AnalyzedFieldTreeNode : AnalyzerEntityTreeNode
 	{

ILSpy/Analyzers/TreeNodes/AnalyzedMethodTreeNode.cs

@@ -22,8 +22,9 @@ using System.Reflection.Metadata;
 using ICSharpCode.Decompiler;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.Analyzers;
+using ICSharpCode.ILSpy.TreeNodes;
 
-namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal class AnalyzedMethodTreeNode : AnalyzerEntityTreeNode
 	{

ILSpy/Analyzers/TreeNodes/AnalyzedPropertyTreeNode.cs

@@ -17,70 +17,45 @@
 // DEALINGS IN THE SOFTWARE.
 
 using System;
-using System.Reflection.Metadata;
+using ICSharpCode.Decompiler.TypeSystem;
-using ICSharpCode.Decompiler;
+using ICSharpCode.ILSpy.TreeNodes;
-using ICSharpCode.Decompiler.Metadata;
 
-namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	sealed class AnalyzedPropertyTreeNode : AnalyzerEntityTreeNode
 	{
-		readonly Decompiler.Metadata.PEFile module;
+		readonly IProperty analyzedProperty;
-		readonly PropertyDefinitionHandle analyzedProperty;
-		readonly bool isIndexer;
 		readonly string prefix;
 
-		public AnalyzedPropertyTreeNode(Decompiler.Metadata.PEFile module, PropertyDefinitionHandle analyzedProperty, string prefix = "")
+		public AnalyzedPropertyTreeNode(IProperty analyzedProperty, string prefix = "")
 		{
-			if (analyzedProperty == null)
+			this.analyzedProperty = analyzedProperty ?? throw new ArgumentNullException(nameof(analyzedProperty));
-				throw new ArgumentNullException(nameof(analyzedProperty));
-			using (LoadedAssembly.DisableAssemblyLoad()) {
-				this.isIndexer = analyzedProperty.HasMatchingDefaultMemberAttribute(module, out _);
-			}
-			this.module = module;
-			this.analyzedProperty = analyzedProperty;
 			this.prefix = prefix;
 			this.LazyLoading = true;
 		}
 
-		public override object Icon => PropertyTreeNode.GetIcon(new Decompiler.Metadata.PropertyDefinition(module, analyzedProperty), isIndexer);
+		public override object Icon => PropertyTreeNode.GetIcon(analyzedProperty);
 
 		// TODO: This way of formatting is not suitable for properties which explicitly implement interfaces.
-		public override object Text => prefix + Language.PropertyToString(new Decompiler.Metadata.PropertyDefinition(module, analyzedProperty), includeNamespace: true, includeTypeName: true, isIndexer: isIndexer);
+		public override object Text => prefix + Language.PropertyToString(analyzedProperty, includeNamespace: true, includeTypeName: true);
 
 		protected override void LoadChildren()
 		{
-			var accessors = module.Metadata.GetPropertyDefinition(analyzedProperty).GetAccessors();
+			if (!analyzedProperty.CanGet)
-			if (!accessors.Getter.IsNil)
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Getter, "get"));
-				this.Children.Add(new AnalyzedPropertyAccessorTreeNode(module, accessors.Getter, "get"));
+			if (!analyzedProperty.CanSet)
-			if (!accessors.Setter.IsNil)
+				this.Children.Add(new AnalyzedAccessorTreeNode(analyzedProperty.Setter, "set"));
-				this.Children.Add(new AnalyzedPropertyAccessorTreeNode(module, accessors.Setter, "set"));
 			//foreach (var accessor in analyzedProperty.OtherMethods)
 			//	this.Children.Add(new AnalyzedPropertyAccessorTreeNode(accessor, null));
 
-			/*if (AnalyzedPropertyOverridesTreeNode.CanShow(analyzedProperty))
+			foreach (var lazy in App.ExportProvider.GetExports<IAnalyzer<IProperty>>()) {
-				this.Children.Add(new AnalyzedPropertyOverridesTreeNode(analyzedProperty));
+				var analyzer = lazy.Value;
-			if (AnalyzedInterfacePropertyImplementedByTreeNode.CanShow(analyzedProperty))
+				if (analyzer.Show(analyzedProperty)) {
-				this.Children.Add(new AnalyzedInterfacePropertyImplementedByTreeNode(analyzedProperty));*/
+					this.Children.Add(new AnalyzerSearchTreeNode<IProperty>(analyzedProperty, analyzer));
-		}
+				}
-
+			}
-		/*public static AnalyzerTreeNode TryCreateAnalyzer(IMemberReference member)
-		{
-			if (CanShow(member))
-				return new AnalyzedPropertyTreeNode((PropertyDefinition)member);
-			else
-				return null;
 		}
 
-		public static bool CanShow(IMemberReference member)
+		public override IEntity Member => analyzedProperty;
-		{
-			if (!(member is PropertyDefinition property))
-				return false;
-
-			return !MainWindow.Instance.CurrentLanguage.ShowMember(property.GetMethod.IsNil ? property.SetMethod : property.GetMethod)
-			    || AnalyzedPropertyOverridesTreeNode.CanShow(property);
-		}*/
-
-		public override Decompiler.Metadata.IMetadataEntity Member => new Decompiler.Metadata.PropertyDefinition(module, analyzedProperty);
 	}
 }

ILSpy/Analyzers/TreeNodes/AnalyzedTypeTreeNode.cs

@@ -19,8 +19,9 @@
 using System;
 using ICSharpCode.Decompiler.TypeSystem;
 using ICSharpCode.ILSpy.Analyzers;
+using ICSharpCode.ILSpy.TreeNodes;
 
-namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+namespace ICSharpCode.ILSpy.Analyzers.TreeNodes
 {
 	internal class AnalyzedTypeTreeNode : AnalyzerEntityTreeNode
 	{