Add simple support for property code completion in the IronPython addin.

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

@@ -107,6 +107,7 @@
     <Compile Include="Src\PythonModuleCompletionItemsFactory.cs" />
     <Compile Include="Src\PythonImportResolver.cs" />
     <Compile Include="Src\PythonNamespaceResolver.cs" />
+    <Compile Include="Src\PythonPropertyResolver.cs" />
     <Compile Include="Src\PythonResolverContext.cs" />
     <Compile Include="Src\PythonSelfResolver.cs" />
     <Compile Include="Src\PythonStandardLibraryPath.cs" />

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

@@ -0,0 +1,57 @@
+// 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 PythonPropertyResolver : IPythonResolver
+	{
+		PythonClassResolver classResolver;
+		
+		public PythonPropertyResolver(PythonClassResolver classResolver)
+		{
+			this.classResolver = classResolver;
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			IProperty property = FindProperty(resolverContext, expressionResult);
+			if (property != null) {
+				return CreateMemberResolveResult(property);
+			}
+			return null;
+		}
+		
+		IProperty FindProperty(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			MemberName memberName = new MemberName(expressionResult.Expression);
+			IClass matchingClass = FindClass(resolverContext, memberName.Type);
+			if (matchingClass != null) {
+				return FindProperty(matchingClass, memberName.Name);
+			}
+			return null;
+		}
+		
+		MemberResolveResult CreateMemberResolveResult(IProperty property)
+		{
+			return new MemberResolveResult(null, null, property);
+		}
+		
+		IClass FindClass(PythonResolverContext resolverContext, string typeName)
+		{
+			return classResolver.GetClass(resolverContext, typeName);
+		}
+		
+		IProperty FindProperty(IClass matchingClass, string memberName)
+		{
+			foreach (IProperty property in matchingClass.Properties) {
+				if (property.Name == memberName) {
+					return property;
+				}
+			}
+			return null;
+		}
+	}
+}

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

@@ -19,16 +19,19 @@ namespace ICSharpCode.PythonBinding
 		PythonStandardModuleResolver standardModuleResolver = new PythonStandardModuleResolver();
 		PythonSelfResolver selfResolver = new PythonSelfResolver();
 		PythonMethodResolver methodResolver;
+		PythonPropertyResolver propertyResolver;
 		
 		List<IPythonResolver> resolvers = new List<IPythonResolver>();
 		
 		public PythonResolver()
 		{
 			methodResolver = new PythonMethodResolver(classResolver, standardModuleResolver);
+			propertyResolver = new PythonPropertyResolver(classResolver);
 			
 			resolvers.Add(importResolver);
 			resolvers.Add(classResolver);
 			resolvers.Add(standardModuleResolver);
+			resolvers.Add(propertyResolver);
 			resolvers.Add(methodResolver);
 			resolvers.Add(selfResolver);
 			resolvers.Add(namespaceResolver);

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

@@ -351,6 +351,7 @@
     <Compile Include="Resolver\PythonSelfResolverTests.cs" />
     <Compile Include="Resolver\ResolveBuiltInRoundMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveClassPropertyTests.cs" />
     <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitTestFixture.cs" />

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

@@ -0,0 +1,85 @@
+// 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 ScriptingUtils = ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveClassPropertyTests
+	{
+		ResolveResult result;
+		ParseInformation parseInfo;
+		IProperty myClassProperty;
+		MockClass myClass;
+		
+		void ResolveClassProperty()
+		{
+			PythonResolverContext context = new PythonResolverContext(parseInfo);
+			ExpressionResult expression = new ExpressionResult("MyClass.MyProperty");
+			
+			PythonResolver resolver = new PythonResolver();
+			result = resolver.Resolve(context, expression);
+		}
+		
+		void CreateParseInfoWithOneClass()
+		{
+			ScriptingUtils.MockProjectContent projectContent = new ScriptingUtils.MockProjectContent();
+			myClass = new MockClass(projectContent, "MyClass");
+			
+			projectContent.ClassToReturnFromGetClass = myClass;
+			projectContent.ClassNameForGetClass = "MyClass";
+			
+			myClassProperty = CreateProperty(myClass);
+			myClass.Properties.Add(myClassProperty);
+			
+			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
+			parseInfo = new ParseInformation(unit);
+		}
+		
+		IProperty CreateProperty(IClass c)
+		{
+			return new DefaultProperty(c, "MyProperty");
+		}
+		
+		[Test]
+		public void Resolve_ClassHasOneProperty_ReturnsMemberResolveResult()
+		{
+			CreateParseInfoWithOneClass();
+			ResolveClassProperty();
+			MemberResolveResult memberResolveResult = result as MemberResolveResult;
+			
+			Assert.IsNotNull(memberResolveResult);
+		}
+		
+		[Test]
+		public void Resolve_ClassHasOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty()
+		{
+			CreateParseInfoWithOneClass();
+			ResolveClassProperty();
+			MemberResolveResult memberResolveResult = result as MemberResolveResult;
+			IMember resolvedMember = memberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassProperty, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ClassHasTwoProperties_MemberResolveResultResolvedTypeIsSecondClassProperty()
+		{
+			CreateParseInfoWithOneClass();
+			DefaultProperty extraProperty = new DefaultProperty(myClass, "ExtraProperty");
+			myClass.Properties.Insert(0, extraProperty);
+			ResolveClassProperty();
+			
+			MemberResolveResult memberResolveResult = result as MemberResolveResult;
+			IMember resolvedMember = memberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassProperty, resolvedMember);
+		}
+	}
+}