Added Analyzers - Interface Event and Property Implemented BY

ILSpy/ILSpy.csproj

@@ -135,7 +135,9 @@
     <Compile Include="TreeNodes\Analyzer\AnalyzedEventAccessorsTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedEventOverridesTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedEventTreeNode.cs" />
+    <Compile Include="TreeNodes\Analyzer\AnalyzedInterfacePropertyImplementedByTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedInterfaceMethodImplementedByTreeNode.cs" />
+    <Compile Include="TreeNodes\Analyzer\AnalyzedInterfaceEventImplementedByTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedTypeExposedByTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedTypeExtensionMethodsTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedTypeInstantiationsTreeNode.cs" />

ILSpy/TreeNodes/Analyzer/AnalyzedEventTreeNode.cs

@@ -61,6 +61,8 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				this.Children.Add(new AnalyzedEventAccessorsTreeNode(analyzedEvent));
 			if (AnalyzedEventOverridesTreeNode.CanShow(analyzedEvent))
 				this.Children.Add(new AnalyzedEventOverridesTreeNode(analyzedEvent));
+			if (AnalyzedInterfaceEventImplementedByTreeNode.CanShow(analyzedEvent))
+				this.Children.Add(new AnalyzedInterfaceEventImplementedByTreeNode(analyzedEvent));
 		}
 
 		public static AnalyzerTreeNode TryCreateAnalyzer(MemberReference member)

ILSpy/TreeNodes/Analyzer/AnalyzedInterfaceEventImplementedByTreeNode.cs

@@ -0,0 +1,105 @@
+// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using ICSharpCode.Decompiler.Ast;
+using ICSharpCode.TreeView;
+using Mono.Cecil;
+
+namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+{
+	class AnalyzedInterfaceEventImplementedByTreeNode : AnalyzerTreeNode
+	{
+		EventDefinition analyzedEvent;
+		MethodDefinition analyzedMethod;
+		ThreadingSupport threading;
+
+		public AnalyzedInterfaceEventImplementedByTreeNode(EventDefinition analyzedEvent)
+		{
+			if (analyzedEvent == null)
+				throw new ArgumentNullException("analyzedEvent");
+
+			this.analyzedEvent = analyzedEvent;
+			this.analyzedMethod = this.analyzedEvent.AddMethod ?? this.analyzedEvent.RemoveMethod;
+			this.threading = new ThreadingSupport();
+			this.LazyLoading = true;
+		}
+
+		public override object Text
+		{
+			get { return "Implemented By"; }
+		}
+
+		public override object Icon
+		{
+			get { return Images.Search; }
+		}
+
+		protected override void LoadChildren()
+		{
+			threading.LoadChildren(this, FetchChildren);
+		}
+
+		protected override void OnCollapsing()
+		{
+			if (threading.IsRunning) {
+				this.LazyLoading = true;
+				threading.Cancel();
+				this.Children.Clear();
+			}
+		}
+
+		IEnumerable<SharpTreeNode> FetchChildren(CancellationToken ct)
+		{
+			ScopedWhereUsedScopeAnalyzer<SharpTreeNode> analyzer;
+			analyzer = new ScopedWhereUsedScopeAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
+			return analyzer.PerformAnalysis(ct);
+		}
+
+		IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
+		{
+			if (!type.HasInterfaces)
+				yield break;
+			TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Resolve() == analyzedMethod.DeclaringType);
+			if (implementedInterfaceRef == null)
+				yield break;
+
+			foreach (EventDefinition ev in type.Events.Where(e => e.Name == analyzedEvent.Name)) {
+				MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
+				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
+					yield return new AnalyzedEventTreeNode(ev);
+				yield break;
+			}
+
+			foreach (EventDefinition ev in type.Events.Where(e => e.Name.EndsWith(analyzedEvent.Name))) {
+				MethodDefinition accessor = ev.AddMethod ?? ev.RemoveMethod;
+				if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod)) {
+					yield return new AnalyzedEventTreeNode(ev);
+				}
+			}
+		}
+
+		public static bool CanShow(EventDefinition ev)
+		{
+			return ev.DeclaringType.IsInterface;
+		}
+	}
+}

ILSpy/TreeNodes/Analyzer/AnalyzedInterfacePropertyImplementedByTreeNode.cs

@@ -0,0 +1,105 @@
+// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using ICSharpCode.Decompiler.Ast;
+using ICSharpCode.TreeView;
+using Mono.Cecil;
+
+namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
+{
+	class AnalyzedInterfacePropertyImplementedByTreeNode : AnalyzerTreeNode
+	{
+		PropertyDefinition analyzedProperty;
+		MethodDefinition analyzedMethod;
+		ThreadingSupport threading;
+
+		public AnalyzedInterfacePropertyImplementedByTreeNode(PropertyDefinition analyzedProperty)
+		{
+			if (analyzedProperty == null)
+				throw new ArgumentNullException("analyzedProperty");
+
+			this.analyzedProperty = analyzedProperty;
+			this.analyzedMethod = this.analyzedProperty.GetMethod ?? this.analyzedProperty.SetMethod;
+			this.threading = new ThreadingSupport();
+			this.LazyLoading = true;
+		}
+
+		public override object Text
+		{
+			get { return "Implemented By"; }
+		}
+
+		public override object Icon
+		{
+			get { return Images.Search; }
+		}
+
+		protected override void LoadChildren()
+		{
+			threading.LoadChildren(this, FetchChildren);
+		}
+
+		protected override void OnCollapsing()
+		{
+			if (threading.IsRunning) {
+				this.LazyLoading = true;
+				threading.Cancel();
+				this.Children.Clear();
+			}
+		}
+
+		IEnumerable<SharpTreeNode> FetchChildren(CancellationToken ct)
+		{
+			ScopedWhereUsedScopeAnalyzer<SharpTreeNode> analyzer;
+			analyzer = new ScopedWhereUsedScopeAnalyzer<SharpTreeNode>(analyzedMethod, FindReferencesInType);
+			return analyzer.PerformAnalysis(ct);
+		}
+
+		IEnumerable<SharpTreeNode> FindReferencesInType(TypeDefinition type)
+		{
+			if (!type.HasInterfaces)
+				yield break;
+			TypeReference implementedInterfaceRef = type.Interfaces.FirstOrDefault(i => i.Resolve() == analyzedMethod.DeclaringType);
+			if (implementedInterfaceRef == null)
+				yield break;
+
+			foreach (PropertyDefinition property in type.Properties.Where(e => e.Name == analyzedProperty.Name)) {
+				MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
+				if (TypesHierarchyHelpers.MatchInterfaceMethod(accessor, analyzedMethod, implementedInterfaceRef))
+					yield return new AnalyzedPropertyTreeNode(property);
+				yield break;
+			}
+
+			foreach (PropertyDefinition property in type.Properties.Where(e => e.Name.EndsWith(analyzedProperty.Name))) {
+				MethodDefinition accessor = property.GetMethod ?? property.SetMethod;
+				if (accessor.HasOverrides && accessor.Overrides.Any(m => m.Resolve() == analyzedMethod)) {
+					yield return new AnalyzedPropertyTreeNode(property);
+				}
+			}
+		}
+
+		public static bool CanShow(PropertyDefinition property)
+		{
+			return property.DeclaringType.IsInterface;
+		}
+	}
+}

ILSpy/TreeNodes/Analyzer/AnalyzedPropertyTreeNode.cs

@@ -64,9 +64,8 @@ namespace ICSharpCode.ILSpy.TreeNodes.Analyzer
 				this.Children.Add(new AnalyzedPropertyAccessorsTreeNode(analyzedProperty));
 			if (AnalyzedPropertyOverridesTreeNode.CanShow(analyzedProperty))
 				this.Children.Add(new AnalyzedPropertyOverridesTreeNode(analyzedProperty));
-			//if (analyzedProperty.HasBody)
+			if (AnalyzedInterfacePropertyImplementedByTreeNode.CanShow(analyzedProperty))
-			//    this.Children.Add(new AnalyzedMethodUsesNode(analyzedProperty));
+				this.Children.Add(new AnalyzedInterfacePropertyImplementedByTreeNode(analyzedProperty));
-			//this.Children.Add(new AnalyzedMethodUsedByTreeNode(analyzedProperty));
 		}
 
 		public static AnalyzerTreeNode TryCreateAnalyzer(MemberReference member)