Fixed some completion cases with extension methods.

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

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

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));
+		}
+
 	}
 }