Add support for IronPython completion after typing 'self'.

src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj

@@ -106,6 +106,7 @@
     <Compile Include="Src\PythonImportResolver.cs" />
     <Compile Include="Src\PythonNamespaceResolver.cs" />
     <Compile Include="Src\PythonResolverContext.cs" />
+    <Compile Include="Src\PythonSelfResolver.cs" />
     <Compile Include="Src\PythonStandardLibraryPath.cs" />
     <Compile Include="Src\PythonStandardModuleMethodResolver.cs" />
     <Compile Include="Src\PythonStandardModuleMethodResolveResult.cs" />

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

@@ -17,6 +17,7 @@ namespace ICSharpCode.PythonBinding
 		PythonNamespaceResolver namespaceResolver = new PythonNamespaceResolver();
 		PythonClassResolver classResolver = new PythonClassResolver();
 		PythonStandardModuleResolver standardModuleResolver = new PythonStandardModuleResolver();
+		PythonSelfResolver selfResolver = new PythonSelfResolver();
 		PythonMethodResolver methodResolver;
 		
 		List<IPythonResolver> resolvers = new List<IPythonResolver>();
@@ -29,6 +30,7 @@ namespace ICSharpCode.PythonBinding
 			resolvers.Add(classResolver);
 			resolvers.Add(standardModuleResolver);
 			resolvers.Add(methodResolver);
+			resolvers.Add(selfResolver);
 			resolvers.Add(namespaceResolver);
 		}
 		

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

@@ -52,6 +52,10 @@ namespace ICSharpCode.PythonBinding
 			get { return callingClass; }
 		}
 		
+		public bool HasCallingClass {
+			get { return callingClass != null; }
+		}
+		
 		public bool NamespaceExistsInProjectReferences(string name)
 		{
 			return projectContent.NamespaceExists(name);

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

@@ -0,0 +1,33 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonSelfResolver : IPythonResolver
+	{
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			if (resolverContext.HasCallingClass) {
+				if (IsSelfExpression(expressionResult)) {
+					return CreateResolveResult(resolverContext);
+				}
+			}
+			return null;
+		}
+		
+		bool IsSelfExpression(ExpressionResult expressionResult)
+		{
+			return expressionResult.Expression == "self";
+		}
+		
+		ResolveResult CreateResolveResult(PythonResolverContext resolverContext)
+		{
+			IClass callingClass = resolverContext.CallingClass;
+			IReturnType returnType = callingClass.DefaultReturnType;
+			return new ResolveResult(callingClass, null, returnType);
+		}
+	}
+}

src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj

@@ -348,6 +348,7 @@
     <Compile Include="Resolver\ImportModuleResolveResultTests.cs" />
     <Compile Include="Resolver\InvalidResolveInputsTestFixture.cs" />
     <Compile Include="Resolver\MemberNameTests.cs" />
+    <Compile Include="Resolver\PythonSelfResolverTests.cs" />
     <Compile Include="Resolver\ResolveBuiltInRoundMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
     <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
@@ -371,6 +372,7 @@
     <Compile Include="Resolver\ResolverContextHasImportTests.cs" />
     <Compile Include="Resolver\ResolverContextPartialNamespaceExistsTests.cs" />
     <Compile Include="Resolver\ResolverContextUnaliasImportedModuleNameTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSelfTests.cs" />
     <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleTestFixture.cs">

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

@@ -0,0 +1,49 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class PythonSelfResolverTests
+	{
+		PythonSelfResolver resolver;
+		ExpressionResult expression;
+		ParseInformation parseInfo;
+		PythonResolverContext context;
+		
+		[Test]
+		public void Resolve_NoCallingClass_ReturnsNull()
+		{
+			CreatePythonSelfResolver();
+			CreateParseInfo();
+			CreatePythonResolverContext();
+			
+			ResolveResult result = resolver.Resolve(context, expression);
+			Assert.IsNull(result);
+		}
+		
+		void CreatePythonSelfResolver()
+		{
+			resolver = new PythonSelfResolver();
+			expression = new ExpressionResult("self");
+		}
+		
+		void CreateParseInfo()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
+			parseInfo = new ParseInformation(unit);
+		}
+		
+		void CreatePythonResolverContext()
+		{
+			context = new PythonResolverContext(parseInfo);
+		}
+	}
+}

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

@@ -0,0 +1,45 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSelfTests : ResolveTestFixtureBase
+	{
+		IClass fooClass;
+		
+		protected override ExpressionResult GetExpressionResult()
+		{
+			fooClass = compilationUnit.Classes[0];
+			return new ExpressionResult("self", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"class Foo(self)\r\n" +
+				"    def bar(self):\r\n" +
+				"        self\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsSelf_ResolveResultResolvedTypeUnderlyingClassReturnsFooClass()
+		{
+			IClass underlyingClass = resolveResult.ResolvedType.GetUnderlyingClass();
+			Assert.AreEqual(fooClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsSelf_ResolveResultCallingClassReturnsFooClass()
+		{
+			IClass underlyingClass = resolveResult.CallingClass;
+			Assert.AreEqual(fooClass, underlyingClass);
+		}
+	}
+}