Add support for IronPython code completion on methods after typing 'self'.

src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonSelfResolver.cs

@@ -13,6 +13,9 @@ namespace ICSharpCode.PythonBinding
 			if (resolverContext.HasCallingClass) {
 				if (IsSelfExpression(expressionResult)) {
 					return CreateResolveResult(resolverContext);
+				} else if (IsSelfExpressionAtStart(expressionResult)) {
+					MemberName memberName = new MemberName(expressionResult.Expression);
+					return new PythonMethodGroupResolveResult(resolverContext.CallingClass, memberName.Name);
 				}
 			}
 			return null;
@@ -29,5 +32,10 @@ namespace ICSharpCode.PythonBinding
 			IReturnType returnType = callingClass.DefaultReturnType;
 			return new ResolveResult(callingClass, null, returnType);
 		}
+		
+		bool IsSelfExpressionAtStart(ExpressionResult expressionResult)
+		{
+			return expressionResult.Expression.StartsWith("self.");
+		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSelfTests.cs

@@ -4,41 +4,80 @@
 using System;
 using ICSharpCode.SharpDevelop.Dom;
 using NUnit.Framework;
+using PythonBinding.Tests.Utils;
 using UnitTesting.Tests.Utils;
 
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSelfTests : ResolveTestsBase
+	public class ResolveSelfTests
 	{
 		IClass fooClass;
+		PythonResolverTestsHelper resolverHelper;
 		
-		protected override ExpressionResult GetExpressionResult()
+		void CreateResolver(string code)
 		{
-			fooClass = compilationUnit.Classes[0];
-			return new ExpressionResult("self", ExpressionContext.Default);
+			resolverHelper = new PythonResolverTestsHelper(code);
+			fooClass = resolverHelper.CompilationUnit.Classes[0];
 		}
 		
-		protected override string GetPythonScript()
+		[Test]
+		public void Resolve_ExpressionIsSelf_ResolveResultResolvedTypeUnderlyingClassReturnsFooClass()
 		{
-			return 
-				"class Foo(self)\r\n" +
+			ResolveSelfExpression();
+			IClass underlyingClass = resolverHelper.ResolveResult.ResolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(fooClass, underlyingClass);
+		}
+		
+		void ResolveSelfExpression()
+		{
+			string code =
+				"class Foo:\r\n" +
 				"    def bar(self):\r\n" +
 				"        self\r\n" +
 				"\r\n";
+			
+			CreateResolver(code);
+			resolverHelper.Resolve("self");
 		}
 		
 		[Test]
-		public void Resolve_ExpressionIsSelf_ResolveResultResolvedTypeUnderlyingClassReturnsFooClass()
+		public void Resolve_ExpressionIsSelf_ResolveResultCallingClassReturnsFooClass()
 		{
-			IClass underlyingClass = resolveResult.ResolvedType.GetUnderlyingClass();
+			ResolveSelfExpression();
+			IClass underlyingClass = resolverHelper.ResolveResult.CallingClass;
+			
 			Assert.AreEqual(fooClass, underlyingClass);
 		}
 		
 		[Test]
-		public void Resolve_ExpressionIsSelf_ResolveResultCallingClassReturnsFooClass()
+		public void Resolve_ExpressionIsSelfFollowedByMethodCall_MethodGroupResolveResultNameIsMethodCalled()
+		{
+			ResolveSelfMethodExpression();
+			string methodName = resolverHelper.MethodGroupResolveResult.Name;
+			
+			Assert.AreEqual("bar", methodName);
+		}
+		
+		void ResolveSelfMethodExpression()
+		{
+			string code =
+				"class Foo:\r\n" +
+				"    def bar(self):\r\n" +
+				"        return 0\r\n" +
+				"\r\n";
+			
+			CreateResolver(code);
+			resolverHelper.Resolve("self.bar");
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsSelfFollowedByMethodCall_MethodGroupResolveResultContainingTypeUnderlyingClassIsFooClass()
 		{
-			IClass underlyingClass = resolveResult.CallingClass;
+			ResolveSelfMethodExpression();
+			IClass underlyingClass = resolverHelper.MethodGroupResolveResult.ContainingType.GetUnderlyingClass();
+			
 			Assert.AreEqual(fooClass, underlyingClass);
 		}
 	}

src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/PythonResolverTestsHelper.cs

@@ -37,6 +37,7 @@ namespace PythonBinding.Tests.Utils
 		{
 			ExpressionResult expressionResult = new ExpressionResult(expression);
 			PythonResolverContext context = new PythonResolverContext(ParseInfo);
+			context.GetCallingMember(expressionResult.Region);
 			ResolveResult = Resolver.Resolve(context, expressionResult);
 			return ResolveResult;
 		}
@@ -61,6 +62,10 @@ namespace PythonBinding.Tests.Utils
 			get { return ResolveResult as LocalResolveResult; }
 		}
 		
+		public MethodGroupResolveResult MethodGroupResolveResult {
+			get { return ResolveResult as MethodGroupResolveResult; }
+		}
+		
 		public MockClass CreateClass(string name)
 		{
 			return new MockClass(ProjectContent, name);