[CodeIssues] Improve ParameterCouldBeDemotedIssue.

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/ParameterCanBeDemotedIssue/ParameterCanBeDemotedIssue.cs

@@ -68,8 +68,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 						continue;
 					var currentType = localResolveResult.Type;
 					var candidateTypes = localResolveResult.Type.GetAllBaseTypes().ToList();
-					candidateTypes.Add(localResolveResult.Type);
-					var possibleTypes = GetLeastDerivedImplementors(candidateTypes, invocations);
+					var possibleTypes = GetPossibleTypes(candidateTypes, invocations);
 					var suggestedTypes = possibleTypes.Where(t => t != currentType);
 					if (suggestedTypes.Any())
 						AddIssue(parameter, context.TranslateString("Parameter can be demoted to base class"),
@@ -89,45 +88,45 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				}
 			}
 
-			static IEnumerable<IMember> GetDeclaredMembers(IMember member)
+			HashSet<IMember> GetNeededMembers(IEnumerable<InvocationResolveResult> invocations)
 			{
-				var implementedInterfaceMembers = member.ImplementedInterfaceMembers;
-				if (implementedInterfaceMembers.Count == 0) {
-					yield return member;
-				}
-				else {
-					foreach (var interfaceMember in implementedInterfaceMembers) {
-						yield return interfaceMember;
-					}
+				var members = new HashSet<IMember>();
+				foreach (var invocation in invocations) {
+					members.Add(invocation.Member);
 				}
+				return members;
 			}
 
-			HashSet<IMember> GetNeededMembers(IEnumerable<InvocationResolveResult> invocations)
+			static bool HasCommonMemberDeclaration(IEnumerable<IMember> acceptableMembers, IMember member)
 			{
-				var members = new HashSet<IMember>();
-				foreach (var invocation in invocations) {
-					foreach (var member in GetDeclaredMembers(invocation.Member)) {
-						members.Add(member);
+				var implementedInterfaceMembers = member.MemberDefinition.ImplementedInterfaceMembers;
+				if (implementedInterfaceMembers.Any()) {
+					return acceptableMembers.ContainsAny(implementedInterfaceMembers);
 				}
+				else {
+					return acceptableMembers.Contains(member.MemberDefinition);
 				}
-				return members;
 			}
 
-			bool SatisfiesMemberRequests(IType type, HashSet<IMember> members)
+			bool SatisfiesMemberRequests(IType candidateType, HashSet<IMember> wantedMembers)
 			{
-				var unsatisfiedMembers = new HashSet<IMember>(members);
-				foreach (var member in type.GetMembers()) {
-					var interfaceMembers = member.ImplementedInterfaceMembers;
-					if (interfaceMembers.Count > 0) {
-						unsatisfiedMembers.RemoveWhere(m => interfaceMembers.Contains(m));
+				var allMembers = candidateType.GetMembers();
+				foreach (var wantedMember in wantedMembers) {
+					IEnumerable<IMember> acceptableMembers;
+					if (wantedMember.ImplementedInterfaceMembers.Any()) {
+						acceptableMembers = wantedMember.ImplementedInterfaceMembers.ToList();
 					} else {
-						unsatisfiedMembers.RemoveWhere(m => m == member);
+						acceptableMembers = new List<IMember>() { wantedMember.MemberDefinition };
 					}
+
+					var hasMember = allMembers.Any(m => HasCommonMemberDeclaration(acceptableMembers, m));
+					if (!hasMember)
+						return false;
 				}
-				return unsatisfiedMembers.Count == 0;
+				return true;
 			}
 
-			IEnumerable<IType> GetLeastDerivedImplementors(IEnumerable<IType> types, IEnumerable<InvocationResolveResult> invocations)
+			IEnumerable<IType> GetPossibleTypes(IEnumerable<IType> types, IEnumerable<InvocationResolveResult> invocations)
 			{
 				var members = GetNeededMembers(invocations);
 				return from type in types
@@ -176,5 +175,17 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			}
 		}
 	}
+	
+	static class IEnumerableExtensions
+	{
+		public static bool ContainsAny<T>(this IEnumerable<T> collection, IEnumerable<T> items)
+		{
+			foreach (var item in items) {
+				if (collection.Contains(item))
+					return true;
+			}
+			return false;
+		}
+	}
 }
 

ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/ParameterCanBeDemotedIssue/ParameterCanBeDemotedTests.cs

@@ -27,7 +27,6 @@ using System;
 using NUnit.Framework;
 using ICSharpCode.NRefactory.CSharp.CodeActions;
 using ICSharpCode.NRefactory.CSharp.Refactoring;
-using System.Linq;
 
 namespace ICSharpCode.NRefactory.CSharp.CodeIssues
 {
@@ -57,6 +56,8 @@ class C
 			TestRefactoringContext context;
 			var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 			Assert.AreEqual(1, issues.Count);
+			var issue = issues [0];
+			Assert.AreEqual(1, issue.Actions.Count);
 			
 			CheckFix(context, issues [0], @"
 class A
@@ -100,6 +101,8 @@ class C
 			TestRefactoringContext context;
 			var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 			Assert.AreEqual(1, issues.Count);
+			var issue = issues [0];
+			Assert.AreEqual(1, issue.Actions.Count);
 			
 			CheckFix(context, issues [0], @"
 interface IA
@@ -121,6 +124,64 @@ class C
 			);
 		}
 		
+		[Test]
+		public void MultipleInterfaceTest()
+		{
+			var input = @"
+interface IA1
+{
+	void Foo();
+}
+interface IA2
+{
+	void Bar();
+}
+class B : IA1, IA2
+{
+	public virtual void Foo() {}
+	public virtual void Bar() {}
+}
+class C : B {}
+class Test
+{
+	void F(C c)
+	{
+		c.Foo();
+		c.Bar();
+	}
+}";
+			TestRefactoringContext context;
+			var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
+			Assert.AreEqual(1, issues.Count);
+			var issue = issues [0];
+			Assert.AreEqual(1, issue.Actions.Count);
+
+			CheckFix(context, issues [0], @"
+interface IA1
+{
+	void Foo();
+}
+interface IA2
+{
+	void Bar();
+}
+class B : IA1, IA2
+{
+	public virtual void Foo() {}
+	public virtual void Bar() {}
+}
+class C : B {}
+class Test
+{
+	void F(B c)
+	{
+		c.Foo();
+		c.Bar();
+	}
+}"
+			);
+		}
+
 		string baseInput = @"
 interface IA
 {
@@ -160,7 +221,9 @@ class Test
 			TestRefactoringContext context;
 			var issues = GetIssues(new ParameterCanBeDemotedIssue(), input, out context);
 			Assert.AreEqual(1, issues.Count);
-			var fixes = issues [0].Actions;
+			var issue = issues [0];
+			Assert.AreEqual(4, issue.Actions.Count);
+
 			CheckFix(context, issues [0], baseInput + @"
 class Test
 {
@@ -168,7 +231,8 @@ class Test
 	{
 		d.Foo();
 	}
-}");
+}"
+			);
 		}
 	}
 }