Fixed some completion cases with extension methods.

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -2327,37 +2327,44 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			}
 		}
 
-		IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, SyntaxTree unit, int parameter, bool controlSpace)
+		void CreateParameterForInvocation(CompletionDataWrapper result, IMethod method, CSharpResolver state, int parameter, HashSet<string> addedEnums, HashSet<string> addedDelegates)
 		{
-			var result = new CompletionDataWrapper(this);
-			var addedEnums = new HashSet<string>();
-			var addedDelegates = new HashSet<string>();
-			
-			foreach (var method in resolveResult.Methods) {
 			if (method.Parameters.Count <= parameter) {
-					continue;
+				return;
 			}
 			var resolvedType = method.Parameters[parameter].Type;
 			if (resolvedType.Kind == TypeKind.Enum) {
 				if (addedEnums.Contains(resolvedType.ReflectionName)) {
-						continue;
+					return;
 				}
 				addedEnums.Add(resolvedType.ReflectionName);
 				AddEnumMembers(result, resolvedType, state);
-				} else if (resolvedType.Kind == TypeKind.Delegate) {
+				return;
+			}
+
+			if (resolvedType.Kind == TypeKind.Delegate) {
 				if (addedDelegates.Contains(resolvedType.ReflectionName))
-						continue;
+				return;
 				string parameterDefinition = AddDelegateHandlers(result, resolvedType, false);
 				string varName = "Handle" + method.Parameters[parameter].Type.Name + method.Parameters[parameter].Name;
-					result.Result.Add(
+				result.Result.Add(factory.CreateEventCreationCompletionData(varName, resolvedType, null, parameterDefinition, currentMember, currentType));
-						factory.CreateEventCreationCompletionData(
+			}
-						varName,
+		}
-						resolvedType,
+		
-						null,
+		IEnumerable<ICompletionData> CreateParameterCompletion(MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, SyntaxTree unit, int parameter, bool controlSpace)
-						parameterDefinition,
+		{
-						currentMember,
+			var result = new CompletionDataWrapper(this);
-						currentType)
+			var addedEnums = new HashSet<string>();
-						);
+			var addedDelegates = new HashSet<string>();
+			
+			foreach (var method in resolveResult.Methods) {
+				CreateParameterForInvocation(result, method, state, parameter, addedEnums, addedDelegates);
+			}
+			foreach (var methods in resolveResult.GetEligibleExtensionMethods (true)) {
+				foreach (var method in methods) {
+					if (resolveResult.Methods.Contains (method))
+						continue;
+					CreateParameterForInvocation(result, new ReducedExtensionMethod (method), state, parameter, addedEnums, addedDelegates);
 				}
 			}
 			

ICSharpCode.NRefactory.CSharp/Completion/CSharpParameterCompletionEngine.cs

@@ -129,11 +129,14 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				}
 				methods.Add (method);
 			}
-			foreach (var m in methods)
+			foreach (var m in methods) {
 				yield return m;
+			}
 			foreach (var extMethods in resolveResult.GetEligibleExtensionMethods (true)) {
 				foreach (var method in extMethods) {
-					yield return method;
+					if (methods.Contains (method))
+						continue;
+					yield return new ReducedExtensionMethod (method);
 				}
 			}
 		}

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeCompletionAccessibleTests.cs

@@ -1131,6 +1131,46 @@ class TestClass
 			Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
 		}
 	
+		[Test]
+		public void TestEnumInExtensionMethod()
+		{
+			var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider(@"
+public enum TestEnum { A, B, C}
+static class Ext { public static void Foo(this object o, TestEnum str) {} }
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$args.Foo($
+	}
+}");
+			Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
+		}
+		
+		
+		[Test]
+		public void TestEnumInExtensionMethodStaticInvocation()
+		{
+			var provider = CodeCompletionBugTests.CreateCtrlSpaceProvider(@"
+public enum TestEnum { A, B, C}
+static class Ext { public static void Foo(this object o, TestEnum str) {} }
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$Ext.Foo(args, $
+	}
+}");
+			Assert.IsNotNull (provider.Find ("TestEnum"), "enum 'TestEnum' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.A"), "enum 'TestEnum.A' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.B"), "enum 'TestEnum.B' not found.");
+			Assert.IsNotNull (provider.Find ("TestEnum.C"), "enum 'TestEnum.C' not found.");
+		}
+
+
 		[Test()]
 		public void TestEnumAsParameterCase2 ()
 		{

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/ParameterCompletionTests.cs

@@ -1130,5 +1130,36 @@ public class Test
 			Assert.AreEqual (1, provider.Count);
 		}
 
+		[Test]
+		public void TestExtensionMethod()
+		{
+			var provider = CreateProvider(@"static class Ext { public static void Foo(this object o, string str) {} }
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$args.Foo($
+	}
+}");
+			Assert.AreEqual (1, provider.Count);
+			Assert.AreEqual (1, provider.GetParameterCount (0));
+		}
+		
+		
+		[Test]
+		public void TestExtensionMethodStaticInvocation()
+		{
+			var provider = CreateProvider(@"static class Ext { public static void Foo(this object o, string str) {} }
+class Test
+{
+	public static void Main (string[] args)
+	{
+		$Ext.Foo($
+	}
+}");
+			Assert.AreEqual (1, provider.Count);
+			Assert.AreEqual (2, provider.GetParameterCount (0));
+		}
+
 	}
 }