Merge branch 'reports' of github.com:icsharpcode/SharpDevelop into reports

data/templates/project/CSharp/WebService.xpt

@@ -31,9 +31,16 @@
 		<PropertyGroup>
 			<OutputType>Library</OutputType>
 			<AppDesignerFolder>Properties</AppDesignerFolder>
-			<OutputPath>bin\</OutputPath>
 			<ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
 		</PropertyGroup>
+		
+		<PropertyGroup configuration="Debug">
+			<OutputPath>bin\</OutputPath>
+		</PropertyGroup>
+		
+		<PropertyGroup configuration="Release">
+			<OutputPath>bin\</OutputPath>
+		</PropertyGroup>
 
 	<Files>
 		<File name="Soap.cs" DependentUpon="Default.asmx"><![CDATA[${StandardHeader.C#}

data/templates/project/CSharp/WebpageProject.xpt

@@ -31,10 +31,16 @@
 		
 		<PropertyGroup>
 			<OutputType>Library</OutputType>
-			<OutputPath>bin\</OutputPath>
 			<ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
 		</PropertyGroup>
-
+		
+		<PropertyGroup configuration="Debug">
+			<OutputPath>bin\</OutputPath>
+		</PropertyGroup>
+		
+		<PropertyGroup configuration="Release">
+			<OutputPath>bin\</OutputPath>
+		</PropertyGroup>
 	<Files>
 <!--*************************************************************************-->
 		<File name=".\Default.aspx.cs" DependentUpon="Default.aspx"><![CDATA[${StandardHeader.C#}

src/AddIns/Analysis/CodeAnalysis/CodeAnalysis.csproj

@@ -18,6 +18,8 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <IntermediateOutputPath>obj\Debug\</IntermediateOutputPath>

src/AddIns/Analysis/CodeCoverage/Project/CodeCoverage.csproj

@@ -17,6 +17,8 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <OutputPath>..\..\..\..\..\AddIns\Analysis\CodeCoverage\</OutputPath>

src/AddIns/Analysis/Profiler/Controller/Profiler.Controller.csproj

@@ -46,6 +46,7 @@
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/Analysis/Profiler/Frontend/AddIn/Profiler.AddIn.csproj

@@ -31,6 +31,8 @@
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/Analysis/Profiler/Frontend/AddIn/Src/Extensions.cs

@@ -37,7 +37,7 @@ namespace ICSharpCode.Profiler.AddIn
 				if (!project.ReadOnly) {
 					FileProjectItem file = new FileProjectItem(project, ItemType.Content, "ProfilingSessions\\" + Path.GetFileName(path));
 					ProjectService.AddProjectItem(project, file);
-					ProjectBrowserPad.Instance.ProjectBrowserControl.RefreshView();
+					ProjectBrowserPad.RefreshViewAsync();
 					project.Save();
 				}
 			};

src/AddIns/Analysis/Profiler/Frontend/Controls/Profiler.Controls.csproj

@@ -34,6 +34,7 @@
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/Analysis/Profiler/X64Converter/Profiler.X64Converter.csproj

@@ -33,6 +33,7 @@
     <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/Analysis/SourceAnalysis/SourceAnalysis.csproj

@@ -20,6 +20,8 @@
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <RunCodeAnalysis>False</RunCodeAnalysis>
     <RunSourceAnalysis>False</RunSourceAnalysis>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <IntermediateOutputPath>obj\Debug\</IntermediateOutputPath>

src/AddIns/Analysis/UnitTesting/Test/UnitTesting.Tests.csproj

@@ -194,7 +194,7 @@
     <Compile Include="Utils\Tests\MockAddInTreeTestFixture.cs" />
     <Compile Include="Utils\Tests\MockBuildOptionsTestFixture.cs" />
     <Compile Include="Utils\Tests\MockBuildProjectBeforeTestRunTestFixture.cs" />
-    <Compile Include="Utils\Tests\MockClassTestFixture.cs" />
+    <Compile Include="Utils\Tests\MockClassTests.cs" />
     <Compile Include="Utils\Tests\MockDebuggerServiceTestFixture.cs" />
     <Compile Include="Utils\Tests\MockFileServiceTestFixture.cs" />
     <Compile Include="Utils\Tests\MockMessageServiceTestFixture.cs" />

src/AddIns/Analysis/UnitTesting/Test/Utils/MockClass.cs

@@ -128,5 +128,32 @@ namespace UnitTesting.Tests.Utils
 			DefaultReturnType returnType = new DefaultReturnType(baseClass);
 			BaseTypes.Add(returnType);
 		}
+		
+		public DefaultProperty AddProperty(string name)
+		{
+			DefaultProperty property = new DefaultProperty(this, name);
+			Properties.Add(property);
+			return property;
+		}
+		
+		public void InsertPropertyAtStart(string name)
+		{
+			DefaultProperty property = new DefaultProperty(this, name);
+			Properties.Insert(0, property);
+		}
+		
+		public DefaultEvent AddEvent(string name)
+		{
+			DefaultEvent classEvent = new DefaultEvent(this, name);
+			Events.Add(classEvent);
+			return classEvent;
+		}
+		
+		public DefaultField AddField(string name)
+		{
+			DefaultField field = new DefaultField(this, name);
+			Fields.Add(field);
+			return field;
+		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockClassTestFixture.cs

@@ -1,163 +0,0 @@
-// 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 ICSharpCode.SharpDevelop.Project;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Utils.Tests
-{
-	[TestFixture]
-	public class MockClassTestFixture
-	{
-		MockClass outerClass;
-		MockClass innerClass;
-		
-		[Test]
-		public void ClassCreatedWithExpectedFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			Assert.AreEqual(fullyQualifiedName, c.FullyQualifiedName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithFullyQualifiedNameHasMatchingDotNetName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			Assert.AreEqual(fullyQualifiedName, c.DotNetName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithExpectedDotNetName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass.InnerClass";
-			string dotNetName = "MyNamespace.MyClass+InnerClass";
-			MockClass c = new MockClass(fullyQualifiedName, dotNetName);
-			Assert.AreEqual(dotNetName, c.DotNetName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNamespaceTakenFromFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedNamespace = "MyNamespace.MySubNamespace";
-			Assert.AreEqual(expectedNamespace, c.Namespace);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNameTakenFromFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedName = "MyClass";
-			Assert.AreEqual(expectedName, c.Name);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNoNamespaceInFullyQualifiedNameHasNamespaceOfEmptyString()
-		{
-			string fullyQualifiedName = "MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedNamespace = String.Empty;
-			Assert.AreEqual(expectedNamespace, c.Namespace);
-		}
-		
-		[Test]
-		public void ClassHasCompilationUnit()
-		{
-			MockClass c = new MockClass();
-			Assert.IsNotNull(c.CompilationUnit);
-		}
-		
-		[Test]
-		public void ClassHasMockProjectContent()
-		{
-			MockClass c = new MockClass();
-			Assert.IsNotNull(c.ProjectContent as MockProjectContent);
-		}
-		
-		[Test]
-		public void CompoundClassIsClassItself()
-		{
-			MockClass c = new MockClass();
-			Assert.AreEqual(c, c.GetCompoundClass());
-		}
-		
-		[Test]
-		public void ClassDefaultReturnTypeGetUnderlyingClassMatchesOriginalMockClass()
-		{
-			MockClass c = new MockClass();
-			IReturnType returnType = c.DefaultReturnType;
-			Assert.AreEqual(c, returnType.GetUnderlyingClass());
-		}
-		
-		[Test]
-		public void ClassWithInnerClassHasDeclaringTypeAsOuterClass()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(outerClass, innerClass.DeclaringType);
-		}
-		
-		void CreateClassWithInnerClass()
-		{
-			outerClass = new MockClass("MyTests.A");
-			innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest", outerClass);
-		}
-		
-		[Test]
-		public void InnerClassGetCompoundClassReturnsInnerClass()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(innerClass, innerClass.GetCompoundClass());
-		}
-		
-		[Test]
-		public void InnerClassAddedToOuterClassInnerClassCollection()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(innerClass, outerClass.InnerClasses[0]);
-		}
-		
-		[Test]
-		public void ClassAddedToBaseTypesBecomesBaseClass()
-		{
-			MockClass c = new MockClass();
-			MockClass baseClass = new MockClass();
-			DefaultReturnType returnType = new DefaultReturnType(baseClass);
-			c.BaseTypes.Add(returnType);
-			Assert.AreEqual(baseClass, c.BaseClass);
-		}
-		
-		[Test]
-		public void BaseClassPropertyReturnsClassAddedUsingAddBaseClassMethod()
-		{
-			MockClass c = new MockClass();
-			MockClass baseClass = new MockClass();
-			c.AddBaseClass(baseClass);
-			Assert.AreEqual(baseClass, c.BaseClass);
-		}
-		
-		[Test]
-		public void ClassWithProjectContentHasExpectedDotNetName()
-		{
-			MockProjectContent projectContent = new MockProjectContent();
-			string expectedName = "MyNamespace.MyTests";
-			MockClass c = new MockClass(projectContent, expectedName);
-			Assert.AreEqual(expectedName, c.DotNetName);
-		}
-		
-		[Test]
-		public void GetCompoundClassReturnsClassSetWithSetCompoundClass()
-		{
-			MockClass c = new MockClass();
-			MockClass compoundClass = new MockClass();
-			c.SetCompoundClass(compoundClass);
-			Assert.AreEqual(compoundClass, c.GetCompoundClass());
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockClassTests.cs

@@ -0,0 +1,259 @@
+// 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 ICSharpCode.SharpDevelop.Project;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace UnitTesting.Tests.Utils.Tests
+{
+	[TestFixture]
+	public class MockClassTests
+	{
+		MockClass outerClass;
+		MockClass innerClass;
+		
+		[Test]
+		public void FullyQualifiedName_NewInstanceCreatedWithFullyQualifiedName_ReturnsFullyQualifiedName()
+		{
+			string expectedFullyQualifiedName = "MyNamespace.MyClass";
+			MockClass c = new MockClass(expectedFullyQualifiedName);
+			string fullyQualifiedName = c.FullyQualifiedName;
+			Assert.AreEqual(expectedFullyQualifiedName, fullyQualifiedName);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithFullyQualifiedName_ReturnsDotNetNameThatMatchesFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(fullyQualifiedName, dotNetName);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithFullyQualifiedNameAndDotNetName_ReturnsExpectedDotNetName()
+		{
+			string fullyQualifiedName = "MyNamespace.MyClass.InnerClass";
+			string expectedDotNetName = "MyNamespace.MyClass+InnerClass";
+			MockClass c = new MockClass(fullyQualifiedName, expectedDotNetName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(expectedDotNetName, dotNetName);
+		}
+		
+		[Test]
+		public void Namespace_NewInstanceCreatedWithFullyQualifiedName_ReturnsNamespaceTakenFromFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedNamespace = "MyNamespace.MySubNamespace";
+			string actualNamespace = c.Namespace;
+			Assert.AreEqual(expectedNamespace, actualNamespace);
+		}
+		
+		[Test]
+		public void Name_NewInstanceCreatedWithFullyQualifiedName_ReturnsNameTakenFromFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedName = "MyClass";
+			string name = c.Name;
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		[Test]
+		public void Namesapce_NewInstanceCreatedWithFullyQualifiedNameWithNoNamespace_ReturnsEmptyStringAsNamespace()
+		{
+			string fullyQualifiedName = "MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedNamespace = String.Empty;
+			string actualNamespace = c.Namespace;
+			Assert.AreEqual(expectedNamespace, actualNamespace);
+		}
+		
+		[Test]
+		public void CompilationUnit_NewInstanceCreated_ReturnsNonNullCompilationUnit()
+		{
+			MockClass c = new MockClass();
+			ICompilationUnit unit = c.CompilationUnit;
+			Assert.IsNotNull(unit);
+		}
+		
+		[Test]
+		public void ProjectContent_NewInstanceCreated_ReturnsMockProjectContent()
+		{
+			MockClass c = new MockClass();
+			MockProjectContent projectContent = c.ProjectContent as MockProjectContent;
+			Assert.IsNotNull(projectContent);
+		}
+		
+		[Test]
+		public void CompoundClass_NewInstance_ReturnsClassItself()
+		{
+			MockClass c = new MockClass();
+			IClass compoundClass = c.GetCompoundClass();
+			Assert.AreEqual(c, compoundClass);
+		}
+		
+		[Test]
+		public void DefaultReturnTypeGetUnderlyClass_NewInstance_ReturnsOriginalMockClass()
+		{
+			MockClass c = new MockClass();
+			IReturnType returnType = c.DefaultReturnType;
+			IClass underlyingClass = returnType.GetUnderlyingClass();
+			Assert.AreEqual(c, underlyingClass);
+		}
+		
+		[Test]
+		public void DeclaringType_NewInstanceWithInnerClass_InnerClassHasOuterClassAsDeclaringType()
+		{
+			CreateClassWithInnerClass();
+			IClass declaringType = innerClass.DeclaringType;
+			Assert.AreEqual(outerClass, declaringType);
+		}
+		
+		void CreateClassWithInnerClass()
+		{
+			outerClass = new MockClass("MyTests.A");
+			innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest", outerClass);
+		}
+		
+		[Test]
+		public void GetCompoundClass_NewInstanceWithInnerClass_InnerClassReturnsInnerClassAsCompoundClass()
+		{
+			CreateClassWithInnerClass();
+			IClass compoundClass = innerClass.GetCompoundClass();
+			Assert.AreEqual(innerClass, compoundClass);
+		}
+		
+		[Test]
+		public void InnerClasses_NewInstanceCreatedWithInnerClass_FirstClassInCollectionIsInnerClass()
+		{
+			CreateClassWithInnerClass();
+			IClass firstInnerClass = outerClass.InnerClasses[0];
+			Assert.AreEqual(innerClass, firstInnerClass);
+		}
+		
+		[Test]
+		public void BaseClass_ClassAddedToBaseTypes_ClassAddedToBaseTypesBecomesBaseClass()
+		{
+			MockClass c = new MockClass();
+			MockClass baseClass = new MockClass();
+			DefaultReturnType returnType = new DefaultReturnType(baseClass);
+			c.BaseTypes.Add(returnType);
+			IClass actualBaseClass = c.BaseClass;
+			Assert.AreEqual(baseClass, actualBaseClass);
+		}
+		
+		[Test]
+		public void BaseClass_AddBaseClassMethodCalled_ReturnsClassAddedUsingAddBaseClassMethod()
+		{
+			MockClass c = new MockClass();
+			MockClass baseClass = new MockClass();
+			c.AddBaseClass(baseClass);
+			IClass actualBaseClass = c.BaseClass;
+			Assert.AreEqual(baseClass, actualBaseClass);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithProjectContent_ReturnsFullyQualifiedNameAsDotNetName()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			string expectedName = "MyNamespace.MyTests";
+			MockClass c = new MockClass(projectContent, expectedName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(expectedName, dotNetName);
+		}
+		
+		[Test]
+		public void GetCompoundClass_SetCompoundClassMethodCalled_ReturnsClassPassedToSetCompoundClass()
+		{
+			MockClass c = new MockClass();
+			MockClass compoundClass = new MockClass();
+			c.SetCompoundClass(compoundClass);
+			IClass actualCompoundClass = c.GetCompoundClass();
+			Assert.AreEqual(compoundClass, actualCompoundClass);
+		}
+		
+		[Test]
+		public void AddProperty_PassedPropertyName_AddsPropertyToClass()
+		{
+			MockClass c = new MockClass();
+			c.AddProperty("MyProperty");
+			
+			IProperty property = c.Properties[0];
+			string name = property.Name;
+			
+			Assert.AreEqual("MyProperty", name);
+		}
+		
+		[Test]
+		public void InsertPropertyAtStart_PassedPropertyName_AddsPropertyAsFirstProperty()
+		{
+			MockClass c = new MockClass();
+			c.AddProperty("SecondProperty");
+			c.InsertPropertyAtStart("FirstProperty");
+			
+			IProperty property = c.Properties[0];
+			string name = property.Name;
+			
+			Assert.AreEqual("FirstProperty", name);			
+		}
+		
+		[Test]
+		public void AddProperty_PassedPropertyName_ReturnsPropertyWithExpectedName()
+		{
+			MockClass c = new MockClass();
+			IProperty property = c.AddProperty("MyProperty");			
+			string name = property.Name;
+			
+			Assert.AreEqual("MyProperty", name);
+		}
+		
+		[Test]
+		public void AddEvent_PassedEventName_AddsEventToClass()
+		{
+			MockClass c = new MockClass();
+			c.AddEvent("MyEvent");
+			
+			IEvent myEvent = c.Events[0];
+			string name = myEvent.Name;
+			
+			Assert.AreEqual("MyEvent", name);
+		}
+		
+		[Test]
+		public void AddEvent_PassedEventName_ReturnsEventWithExpectedName()
+		{
+			MockClass c = new MockClass();
+			IEvent myEvent = c.AddEvent("MyEvent");			
+			string name = myEvent.Name;
+			
+			Assert.AreEqual("MyEvent", name);
+		}
+		
+		[Test]
+		public void AddField_PassedFieldName_AddsFieldToClass()
+		{
+			MockClass c = new MockClass();
+			c.AddField("MyField");
+			
+			IField myField = c.Fields[0];
+			string name = myField.Name;
+			
+			Assert.AreEqual("MyField", name);
+		}
+		
+		[Test]
+		public void AddField_PassedFieldName_ReturnsFieldWithExpectedName()
+		{
+			MockClass c = new MockClass();
+			IField myField = c.AddField("MyField");			
+			string name = myField.Name;
+			
+			Assert.AreEqual("MyField", name);
+		}
+	}
+}

src/AddIns/Analysis/UnitTesting/UnitTesting.csproj

@@ -18,6 +18,8 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <Optimize>False</Optimize>

src/AddIns/BackendBindings/Boo/BooBinding/Project/BooBinding.csproj

@@ -18,6 +18,8 @@
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <OutputPath>..\..\..\..\..\..\AddIns\BackendBindings\BooBinding\</OutputPath>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <Optimize>False</Optimize>

src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/NRefactoryToBooConverter.csproj

@@ -1,4 +1,5 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <OutputType>Library</OutputType>
     <RootNamespace>NRefactoryToBooConverter</RootNamespace>
@@ -17,6 +18,7 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <OutputPath>bin\Debug\</OutputPath>

src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.csproj

@@ -22,6 +22,8 @@
     <FileAlignment>4096</FileAlignment>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/BackendBindings/CppBinding/CppBinding/CppBinding.csproj

@@ -18,7 +18,8 @@
     </FileUpgradeFlags>
     <OldToolsVersion>3.5</OldToolsVersion>
     <UpgradeBackupLocation />
-    <TargetFrameworkProfile />
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
     <SignAssembly>False</SignAssembly>
     <DelaySign>False</DelaySign>
     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>

src/AddIns/BackendBindings/FSharpBinding/FSharpBinding.addin

@@ -60,16 +60,16 @@
 	</Path>
 	
 	<Path path = "/SharpDevelop/BackendBindings/ProjectOptions/F#">
-		<DialogPanel id    = "Application"
+		<OptionPanel id    = "Application"
 		             label = "${res:Dialog.ProjectOptions.ApplicationSettings}"
 		             class = "ICSharpCode.SharpDevelop.Gui.OptionPanels.ApplicationSettings"/>
-		<DialogPanel id    = "BuildEvents"
+		<OptionPanel id    = "BuildEvents"
 		             label = "${res:Dialog.ProjectOptions.BuildEvents}"
 		             class = "ICSharpCode.SharpDevelop.Gui.OptionPanels.BuildEvents"/>
-		<DialogPanel id    = "BuildOptions"
+		<OptionPanel id    = "BuildOptions"
 		             label = "${res:Dialog.ProjectOptions.BuildOptions}"
 		             class = "CSharpBinding.OptionPanels.BuildOptions"/>
-		<DialogPanel id    = "FsOptions"
+		<OptionPanel id    = "FsOptions"
 		             label = "F# Options"
 		             class = "FSharpBinding.FsOptions"/>
 		<Include id = "AllManaged" path="/SharpDevelop/BackendBindings/ProjectOptions/AllManaged"/>

src/AddIns/BackendBindings/FSharpBinding/FSharpBinding.csproj

@@ -15,6 +15,8 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <OutputPath>..\..\..\..\AddIns\BackendBindings\FSharpBinding\</OutputPath>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Platform)' == 'AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>

src/AddIns/BackendBindings/Python/PyWalker/NRefactoryAstVisitor.cs

@@ -278,11 +278,6 @@ namespace PyWalker
 			return base.VisitIfElseStatement(ifElseStatement, data);
 		}
 		
-		public override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
-		{
-			return base.VisitIndexerDeclaration(indexerDeclaration, data);
-		}
-		
 		public override object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
 		{
 			return base.VisitIndexerExpression(indexerExpression, data);

src/AddIns/BackendBindings/Python/PyWalker/PyWalker.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <ProjectGuid>{55329704-6046-48EC-8A20-5C80B3092A63}</ProjectGuid>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -7,7 +7,7 @@
     <OutputType>WinExe</OutputType>
     <RootNamespace>PyWalker</RootNamespace>
     <AssemblyName>PyWalker</AssemblyName>
-    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
     <NoStdLib>False</NoStdLib>
     <WarningLevel>4</WarningLevel>

src/AddIns/BackendBindings/Python/Python.Build.Tasks/Project/Python.Build.Tasks.csproj

@@ -13,6 +13,8 @@
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <OutputPath>..\..\..\..\..\..\AddIns\BackendBindings\PythonBinding\</OutputPath>

src/AddIns/BackendBindings/Python/PythonBinding.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.0.0.6611
+# SharpDevelop 4.0.0.6676
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding", "PythonBinding\Project\PythonBinding.csproj", "{8D732610-8FC6-43BA-94C9-7126FD7FE361}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding.Tests", "PythonBinding\Test\PythonBinding.Tests.csproj", "{23B517C9-1ECC-4419-A13F-0B7136D085CB}"
@@ -38,6 +38,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Scripting", "..
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Scripting.Tests", "..\Scripting\Test\ICSharpCode.Scripting.Tests.csproj", "{85C09AD8-183B-403A-869A-7226646218A9}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PyWalker", "PyWalker\PyWalker.csproj", "{55329704-6046-48EC-8A20-5C80B3092A63}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -128,5 +130,13 @@ Global
 		{85C09AD8-183B-403A-869A-7226646218A9}.Release|Any CPU.ActiveCfg = Release|x86
 		{85C09AD8-183B-403A-869A-7226646218A9}.Release|x86.Build.0 = Release|x86
 		{85C09AD8-183B-403A-869A-7226646218A9}.Release|x86.ActiveCfg = Release|x86
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Debug|x86.Build.0 = Debug|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Release|Any CPU.Build.0 = Release|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Release|x86.Build.0 = Release|Any CPU
+		{55329704-6046-48EC-8A20-5C80B3092A63}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 EndGlobal

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

@@ -12,6 +12,8 @@
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <OutputPath>..\..\..\..\..\..\AddIns\BackendBindings\PythonBinding\</OutputPath>
@@ -99,6 +101,8 @@
     <Compile Include="Src\PythonFromImport.cs" />
     <Compile Include="Src\PythonImport.cs" />
     <Compile Include="Src\PythonLanguageBinding.cs" />
+    <Compile Include="Src\PythonLocalVariableResolver.cs" />
+    <Compile Include="Src\PythonMemberResolver.cs" />
     <Compile Include="Src\PythonMethodGroupResolveResult.cs" />
     <Compile Include="Src\PythonMethodResolver.cs" />
     <Compile Include="Src\PythonModuleCompletionItems.cs" />
@@ -160,7 +164,6 @@
     <Compile Include="Src\RunDebugPythonCommand.cs" />
     <Compile Include="Src\RunPythonCommand.cs" />
     <Compile Include="Src\PythonStandardModules.cs" />
-    <Compile Include="Src\PythonVariableResolver.cs" />
     <Compile Include="Src\StringTextContentProvider.cs" />
     <None Include="..\..\RequiredLibraries\Chiron.exe.Config">
       <Link>Chiron.exe.Config</Link>

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

@@ -8,6 +8,6 @@ namespace ICSharpCode.PythonBinding
 {
 	public interface IPythonResolver
 	{
-		ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult);
+		ResolveResult Resolve(PythonResolverContext resolverContext);
 	}
 }

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

@@ -10,19 +10,21 @@ namespace ICSharpCode.PythonBinding
 	{
 		PythonResolverContext resolverContext;
 		
-		public PythonClassResolver()
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-		}
+			IClass matchingClass = GetClass(resolverContext);
-		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
-		{
-			IClass matchingClass = GetClass(resolverContext, expressionResult.Expression);
 			if (matchingClass != null) {
 				return CreateTypeResolveResult(matchingClass);
 			}
 			return null;
 		}
 		
+		public IClass GetClass(PythonResolverContext resolverContext)
+		{
+			string name = resolverContext.Expression;
+			return GetClass(resolverContext, name);
+		}
+		
 		public IClass GetClass(PythonResolverContext resolverContext, string name)
 		{
 			this.resolverContext = resolverContext;

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

@@ -4,97 +4,28 @@
 using System;
 using System.Diagnostics;
 using System.Text;
+using ICSharpCode.Scripting;
 
 namespace ICSharpCode.PythonBinding
 {
-	public class PythonConsoleApplication
+	public class PythonConsoleApplication : ScriptingConsoleApplication
 	{
 		PythonAddInOptions options;
-		StringBuilder arguments;
-		bool debug;
-		string pythonScriptFileName = String.Empty;
-		string pythonScriptCommandLineArguments = String.Empty;
-		string workingDirectory = String.Empty;
 		
 		public PythonConsoleApplication(PythonAddInOptions options)
 		{
 			this.options = options;
 		}
 		
-		public string FileName {
+		public override string FileName {
 			get { return options.PythonFileName; }
 		}
-		
+				
-		public bool Debug {
+		protected override void AddArguments(ScriptingCommandLineBuilder commandLine)
-			get { return debug; }
-			set { debug = value; }
-		}
-		
-		public string PythonScriptFileName {
-			get { return pythonScriptFileName; }
-			set { pythonScriptFileName = value; }
-		}
-		
-		public string PythonScriptCommandLineArguments {
-			get { return pythonScriptCommandLineArguments; }
-			set { pythonScriptCommandLineArguments = value; }
-		}
-		
-		public string WorkingDirectory {
-			get { return workingDirectory; }
-			set { workingDirectory = value; }
-		}
-		
-		public ProcessStartInfo GetProcessStartInfo()
-		{
-			ProcessStartInfo processStartInfo = new ProcessStartInfo();
-			processStartInfo.FileName = FileName;
-			processStartInfo.Arguments = GetArguments();
-			processStartInfo.WorkingDirectory = workingDirectory;
-			return processStartInfo;
-		}
-		
-		public string GetArguments()
-		{
-			arguments = new StringBuilder();
-			
-			AppendBooleanOptionIfTrue("-X:Debug", debug);
-			AppendQuotedStringIfNotEmpty(pythonScriptFileName);
-			AppendStringIfNotEmpty(pythonScriptCommandLineArguments);
-			
-			return arguments.ToString().TrimEnd();
-		}
-		
-		void AppendBooleanOptionIfTrue(string option, bool flag)
-		{
-			if (flag) {
-				AppendOption(option);
-			}
-		}
-		
-		void AppendOption(string option)
-		{
-			arguments.Append(option + " ");
-		}
-		
-		void AppendQuotedStringIfNotEmpty(string option)
-		{
-			if (!String.IsNullOrEmpty(option)) {
-				AppendQuotedString(option);
-			}
-		}
-		
-		void AppendQuotedString(string option)
-		{
-			string quotedOption = String.Format("\"{0}\"", option);
-			AppendOption(quotedOption);
-		}
-		
-		void AppendStringIfNotEmpty(string option)
 		{
-			if (!String.IsNullOrEmpty(option)) {
+			commandLine.AppendBooleanOptionIfTrue("-X:Debug", Debug);
-				AppendOption(option);
+			commandLine.AppendQuotedStringIfNotEmpty(ScriptFileName);
-			}
+			commandLine.AppendStringIfNotEmpty(ScriptCommandLineArguments);
 		}
 	}
 }

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

@@ -15,9 +15,9 @@ namespace ICSharpCode.PythonBinding
 			this.classResolver = classResolver;
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-			MemberName memberName = new MemberName(expressionResult.Expression);
+			MemberName memberName = resolverContext.CreateExpressionMemberName();
 			IClass matchingClass = classResolver.GetClass(resolverContext, memberName.Type);
 			if (matchingClass != null) {
 				return new PythonMethodGroupResolveResult(matchingClass, memberName.Name);

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

@@ -8,15 +8,11 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonImportResolver : IPythonResolver
 	{
-		public PythonImportResolver()
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-		}
+			if (IsNamespace(resolverContext.ExpressionResult)) {
-		
+				PythonImportExpression importExpression = new PythonImportExpression(resolverContext.Expression);
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+				PythonImportExpressionContext context = resolverContext.ExpressionContext as PythonImportExpressionContext;
-		{
-			if (IsNamespace(expressionResult)) {
-				PythonImportExpression importExpression = new PythonImportExpression(expressionResult.Expression);
-				PythonImportExpressionContext context = expressionResult.Context as PythonImportExpressionContext;
 				context.HasFromAndImport = importExpression.HasFromAndImport;
 				
 				return new PythonImportModuleResolveResult(importExpression);

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

@@ -0,0 +1,182 @@
+// 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 System.Collections.Generic;
+using System.Text;
+
+using ICSharpCode.Scripting;
+using ICSharpCode.SharpDevelop.Dom;
+using IronPython;
+using IronPython.Compiler;
+using IronPython.Compiler.Ast;
+using IronPython.Hosting;
+using IronPython.Runtime;
+using IronPython.Runtime.Exceptions;
+using Microsoft.Scripting;
+using Microsoft.Scripting.Hosting;
+using Microsoft.Scripting.Runtime;
+
+namespace ICSharpCode.PythonBinding
+{
+	/// <summary>
+	/// Determines the type of a variable.
+	/// </summary>
+	public class PythonLocalVariableResolver : PythonWalker, IPythonResolver
+	{
+		PythonClassResolver classResolver;
+		string variableName = String.Empty;
+		string typeName;
+		AssignmentStatement currentAssignStatement;
+		bool foundVariableAssignment;
+		
+		public PythonLocalVariableResolver(PythonClassResolver classResolver)
+		{
+			this.classResolver = classResolver;
+		}
+		
+		/// <summary>
+		/// The resolved type name.
+		/// </summary>
+		public string TypeName {
+			get { return typeName; }
+		}
+		
+		/// <summary>
+		/// Resolves the type of the variable name specified.
+		/// </summary>
+		/// <param name="variableName">Name of the variable.</param>
+		/// <param name="code">The python code containing the variable.</param>
+		public string Resolve(string variableName, string code)
+		{
+			if (code != null) {
+				PythonParser parser = new PythonParser();
+				PythonAst ast = parser.CreateAst("resolver.py", code);
+				return Resolve(variableName, ast);
+			}
+			return null;
+		}
+		
+		string Resolve(string variableName, PythonAst ast)
+		{
+			this.variableName = variableName;
+			ast.Walk(this);
+			return TypeName;
+		}
+				
+		public override bool Walk(AssignmentStatement node)
+		{
+			currentAssignStatement = node;
+			foundVariableAssignment = false;
+			return base.Walk(node);
+		}		
+		
+		public override bool Walk(NameExpression node)
+		{
+			if (currentAssignStatement != null) {
+				string nodeName = node.Name;
+				if (nodeName == variableName) {
+					foundVariableAssignment = true;
+				}
+			}
+			return base.Walk(node);
+		}
+		
+		public override bool Walk(CallExpression node)
+		{
+			if (foundVariableAssignment) {
+				typeName = GetTypeName(node.Target);
+				currentAssignStatement = null;
+				foundVariableAssignment = false;
+			}
+			return base.Walk(node);
+		}
+		
+		/// <summary>
+		/// Gets the fully qualified name of the type from the expression.
+		/// 
+		/// </summary>
+		/// <remarks>
+		/// The expression is the first target of a call expression.
+		/// 
+		/// A call expression is a method or constructor call (right hand side of expression below):
+		/// 
+		/// a = Root.Test.Class1()
+		/// 
+		/// So the expression passed to this method will be a field expression in the
+		/// above example which refers to Class1. The next target will be a field
+		/// expression referring to Test. The The last target will be a name expression
+		/// referring to Root.
+		/// 
+		/// If we have 
+		/// 
+		/// a = Class1()
+		/// 
+		/// then the expression will be a name expression referring to Class1.
+		/// </remarks>
+		public static string GetTypeName(Expression node)
+		{
+			NameExpression nameExpression = node as NameExpression;
+			if (nameExpression != null) {
+				return nameExpression.Name;
+			}
+			return PythonControlFieldExpression.GetMemberName(node as MemberExpression);
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
+		{
+			return GetLocalVariable(resolverContext);
+		}
+		
+		/// <summary>
+		/// Tries to find the type that matches the local variable name.
+		/// </summary>
+		LocalResolveResult GetLocalVariable(PythonResolverContext resolverContext)
+		{
+			string code = GetLocalMethodCode(resolverContext);
+			string typeName = Resolve(resolverContext.Expression, code);
+			if (typeName != null) {
+				return CreateLocalResolveResult(typeName, resolverContext);
+			}
+			return null;
+		}
+		
+		string GetLocalMethodCode(PythonResolverContext resolverContext)
+		{
+			ScriptingLocalMethod localMethod = new ScriptingLocalMethod(resolverContext.FileContent);
+			int beginLine = resolverContext.ExpressionRegion.BeginLine;
+			return localMethod.GetCode(beginLine);
+		}
+		
+		LocalResolveResult CreateLocalResolveResult(string typeName, PythonResolverContext resolverContext)
+		{
+			IClass resolvedClass = classResolver.GetClass(resolverContext, typeName);
+			if (resolvedClass != null) {
+				string identifier = resolverContext.Expression;
+				return CreateLocalResolveResult(identifier, resolvedClass);
+			}
+			return null;
+		}
+		
+		LocalResolveResult CreateLocalResolveResult(string identifier, IClass resolvedClass)
+		{
+			DefaultMethod dummyMethod = CreateDummyMethod();
+			DefaultField.LocalVariableField field = CreateLocalVariableField(identifier, resolvedClass, dummyMethod.DeclaringType);
+			return new LocalResolveResult(dummyMethod, field);
+		}
+		
+		DefaultField.LocalVariableField CreateLocalVariableField(string identifier, IClass resolvedClass, IClass callingClass)
+		{
+			return new DefaultField.LocalVariableField(resolvedClass.DefaultReturnType,
+				identifier,
+				DomRegion.Empty, 
+				callingClass);
+		}
+		
+		DefaultMethod CreateDummyMethod()
+		{
+			DefaultClass dummyClass = new DefaultClass(DefaultCompilationUnit.DummyCompilationUnit, "Global");
+			return new DefaultMethod(dummyClass, String.Empty);
+		}
+	}
+}

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

@@ -0,0 +1,95 @@
+// 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 System.Collections.Generic;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.PythonBinding
+{
+	/// <summary>
+	/// Resolves properties, events and fields.
+	/// </summary>
+	public class PythonMemberResolver : IPythonResolver
+	{
+		PythonClassResolver classResolver;
+		
+		public PythonMemberResolver(PythonClassResolver classResolver)
+		{
+			this.classResolver = classResolver;
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
+		{
+			IMember member = FindMember(resolverContext);
+			if (member != null) {
+				return CreateMemberResolveResult(member);
+			}
+			return null;
+		}
+		
+		IMember FindMember(PythonResolverContext resolverContext)
+		{
+			return FindMember(resolverContext, resolverContext.Expression);
+		}
+		
+		IMember FindMember(PythonResolverContext resolverContext, string expression)
+		{
+			MemberName memberName = new MemberName(expression);
+			if (memberName.HasName) {
+				IClass c = FindClass(resolverContext, memberName.Type);
+				if (c != null) {
+					return FindMemberInClass(c, memberName.Name);
+				} else {
+					return FindMember(resolverContext, memberName);
+				}
+			}
+			return null;
+		}
+		
+		IClass FindClass(PythonResolverContext resolverContext, string className)
+		{
+			 return classResolver.GetClass(resolverContext, className);
+		}
+		
+		MemberResolveResult CreateMemberResolveResult(IMember member)
+		{
+			return new MemberResolveResult(null, null, member);
+		}
+		
+		IMember FindMemberInClass(IClass matchingClass, string memberName)
+		{
+			List<IMember> members = GetMembers(matchingClass);
+			foreach (IMember member in members) {
+				if (member.Name == memberName) {
+					return member;
+				}
+			}
+			return null;
+		}
+		
+		List<IMember> GetMembers(IClass c)
+		{
+			List<IMember> members = new List<IMember>();
+			members.AddRange(c.Events);
+			members.AddRange(c.Fields);
+			members.AddRange(c.Properties);
+			return members;
+		}
+		
+		IMember FindMember(PythonResolverContext resolverContext, MemberName memberName)
+		{
+			IMember parentMember = FindMember(resolverContext, memberName.Type);
+			if (parentMember != null) {
+				return FindMemberInParent(parentMember, memberName.Name);
+			}
+			return null;
+		}
+		
+		IMember FindMemberInParent(IMember parentMember, string propertyName)
+		{
+			IClass parentMemberClass = parentMember.ReturnType.GetUnderlyingClass();
+			return FindMemberInClass(parentMemberClass, propertyName);
+		}
+	}
+}

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

@@ -17,13 +17,13 @@ namespace ICSharpCode.PythonBinding
 			standardModuleMethodResolver = new PythonStandardModuleMethodResolver(standardModuleResolver);
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-			ResolveResult resolveResult = dotNetMethodResolver.Resolve(resolverContext, expressionResult);
+			ResolveResult resolveResult = dotNetMethodResolver.Resolve(resolverContext);
 			if (resolveResult != null) {
 				return resolveResult;
 			}
-			return standardModuleMethodResolver.Resolve(resolverContext, expressionResult);
+			return standardModuleMethodResolver.Resolve(resolverContext);
 		}
 	}
 }

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

@@ -11,8 +11,9 @@ namespace ICSharpCode.PythonBinding
 		PythonResolverContext resolverContext;
 		ExpressionResult expressionResult;
 		
-		public PythonNamespaceResolver()
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
+			return Resolve(resolverContext, resolverContext.ExpressionResult);
 		}
 		
 		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)

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

@@ -27,10 +27,6 @@ namespace ICSharpCode.PythonBinding
 		string[] lexerTags = new string[0];
 		ScriptEngine scriptEngine;
 		
-		public PythonParser()
-		{
-		}
-		
 		public string[] LexerTags {
 			get { return lexerTags;	}
 			set { lexerTags = value; }
@@ -40,10 +36,6 @@ namespace ICSharpCode.PythonBinding
 			get { return LanguageProperties.None; }
 		}
 		
-		
-		/// <summary>
-		/// Creates a PythonExpressionFinder.
-		/// </summary>
 		public IExpressionFinder CreateExpressionFinder(string fileName)
 		{
 			return new PythonExpressionFinder();
@@ -75,14 +67,22 @@ namespace ICSharpCode.PythonBinding
 		/// <summary>
 		/// Parses a python file and creates a PythonAst.
 		/// </summary>
-		public PythonAst CreateAst(string fileName, ITextBuffer fileContent)
+		public PythonAst CreateAst(string fileName, ITextBuffer textBuffer)
+		{
+			return CreateAst(fileName, textBuffer.Text);
+		}
+		
+		/// <summary>
+		/// Parses a python file and creates a PythonAst.
+		/// </summary>
+		public PythonAst CreateAst(string fileName, string fileContent)
 		{
 			if (scriptEngine == null) {
 				scriptEngine = IronPython.Hosting.Python.CreateEngine();
 			}
 
 			PythonCompilerSink sink = new PythonCompilerSink();
-			SourceUnit source = DefaultContext.DefaultPythonContext.CreateFileUnit(fileName, fileContent.Text);
+			SourceUnit source = DefaultContext.DefaultPythonContext.CreateFileUnit(fileName, fileContent);
 			CompilerContext context = new CompilerContext(source, new PythonCompilerOptions(), sink);
 			using (Parser parser = Parser.CreateParser(context, new PythonOptions())) {
 				return parser.ParseFile(false);	
@@ -92,12 +92,24 @@ namespace ICSharpCode.PythonBinding
 		/// <summary>
 		/// Parses the python code and returns an ICompilationUnit.
 		/// </summary>
-		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, string fileContent)
+		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, ITextBuffer textBuffer)
 		{
-			return Parse(projectContent, fileName, new StringTextBuffer(fileContent));
+			string fileContent = GetFileContent(textBuffer);
+			return Parse(projectContent, fileName, fileContent);
 		}
 		
-		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, ITextBuffer fileContent)
+		string GetFileContent(ITextBuffer textBuffer)
+		{
+			if (textBuffer != null) {
+				return textBuffer.Text;
+			}
+			return null;	
+		}
+		
+		/// <summary>
+		/// Parses the python code and returns an ICompilationUnit.
+		/// </summary>
+		public ICompilationUnit Parse(IProjectContent projectContent, string fileName, string fileContent)
 		{
 			if (fileContent != null) {
 				try { 
@@ -115,9 +127,6 @@ namespace ICSharpCode.PythonBinding
 			return compilationUnit;
 		}
 		
-		/// <summary>
-		/// Creates a new PythonResolver.
-		/// </summary>
 		public IResolver CreateResolver()
 		{
 			return new PythonResolver();

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

@@ -19,19 +19,25 @@ namespace ICSharpCode.PythonBinding
 		PythonStandardModuleResolver standardModuleResolver = new PythonStandardModuleResolver();
 		PythonSelfResolver selfResolver = new PythonSelfResolver();
 		PythonMethodResolver methodResolver;
+		PythonMemberResolver memberResolver;
+		PythonLocalVariableResolver localVariableResolver;
 		
 		List<IPythonResolver> resolvers = new List<IPythonResolver>();
 		
 		public PythonResolver()
 		{
 			methodResolver = new PythonMethodResolver(classResolver, standardModuleResolver);
+			memberResolver = new PythonMemberResolver(classResolver);
+			localVariableResolver = new PythonLocalVariableResolver(classResolver);
 			
 			resolvers.Add(importResolver);
 			resolvers.Add(classResolver);
 			resolvers.Add(standardModuleResolver);
+			resolvers.Add(memberResolver);
 			resolvers.Add(methodResolver);
 			resolvers.Add(selfResolver);
 			resolvers.Add(namespaceResolver);
+			resolvers.Add(localVariableResolver);
 		}
 		
 		public ResolveResult Resolve(ExpressionResult expressionResult, ParseInformation parseInfo, string fileContent)
@@ -40,29 +46,22 @@ namespace ICSharpCode.PythonBinding
 				return null;
 			}
 			
-			resolverContext = new PythonResolverContext(parseInfo);
+			resolverContext = new PythonResolverContext(parseInfo, expressionResult, fileContent);
-			if (!resolverContext.GetCallingMember(expressionResult.Region)) {
+			if (!resolverContext.HasProjectContent) {
 				return null;
 			}
 			
-			return Resolve(resolverContext, expressionResult);
+			return Resolve(resolverContext);
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
 			foreach (IPythonResolver resolver in resolvers) {
-				ResolveResult resolveResult = resolver.Resolve(resolverContext, expressionResult);
+				ResolveResult resolveResult = resolver.Resolve(resolverContext);
 				if (resolveResult != null) {
 					return resolveResult;
 				}
 			}
-			
-//			// Search for a local variable.
-//			LocalResolveResult localResolveResult = GetLocalVariable(expressionResult.Expression, parseInfo.BestCompilationUnit.FileName, fileContent);
-//			if (localResolveResult != null) {
-//				return localResolveResult;
-//			}
-			
 			return null;
 		}
 		
@@ -71,35 +70,25 @@ namespace ICSharpCode.PythonBinding
 		/// </summary>
 		public List<ICompletionEntry> CtrlSpace(int caretLine, int caretColumn, ParseInformation parseInfo, string fileContent, ExpressionContext context)
 		{
-			resolverContext = new PythonResolverContext(parseInfo);
+			resolverContext = new PythonResolverContext(parseInfo, fileContent);
+			return CtrlSpace(resolverContext, context);
+		}
+		
+		List<ICompletionEntry> CtrlSpace(PythonResolverContext resolverContext, ExpressionContext expressionContext)
+		{
 			if (resolverContext.HasProjectContent) {
-				if (context == ExpressionContext.Namespace) {
+				if (expressionContext == ExpressionContext.Namespace) {
-					PythonImportCompletion importCompletion = new PythonImportCompletion(resolverContext.ProjectContent);
+					return GetImportCompletionItems(resolverContext.ProjectContent);
-					return importCompletion.GetCompletionItems();
-				} else {
-					return resolverContext.GetImportedTypes();
 				}
+				return resolverContext.GetImportedTypes();
 			}
 			return new List<ICompletionEntry>();
 		}
 		
-		/// <summary>
+		List<ICompletionEntry> GetImportCompletionItems(IProjectContent projectContent)
-		/// Tries to find the type that matches the local variable name.
-		/// </summary>
-		LocalResolveResult GetLocalVariable(string expression, string fileName, string fileContent)
 		{
-//			PythonVariableResolver resolver = new PythonVariableResolver();
+			PythonImportCompletion importCompletion = new PythonImportCompletion(projectContent);
-//			string typeName = resolver.Resolve(expression, fileName, fileContent);
+			return importCompletion.GetCompletionItems();
-//			if (typeName != null) {
-//				IClass resolvedClass = GetClass(typeName);
-//				if (resolvedClass != null) {
-//					DefaultClass dummyClass = new DefaultClass(DefaultCompilationUnit.DummyCompilationUnit, "Global");
-//					DefaultMethod dummyMethod = new DefaultMethod(dummyClass, String.Empty);
-//					DefaultField.LocalVariableField field = new DefaultField.LocalVariableField(resolvedClass.DefaultReturnType, expression, DomRegion.Empty, dummyClass);
-//					return new LocalResolveResult(dummyMethod, field);
-//				}
-//			}
-			return null;
 		}
 	}
 }

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

@@ -13,24 +13,33 @@ namespace ICSharpCode.PythonBinding
 		ICompilationUnit compilationUnit;
 		IProjectContent projectContent;
 		IClass callingClass;
+		string fileContent;
+		ExpressionResult expressionResult;
 		
 		public PythonResolverContext(ParseInformation parseInfo)
+			: this(parseInfo, String.Empty)
 		{
-			GetCompilationUnits(parseInfo);
-			GetProjectContent();
 		}
 		
-		void GetCompilationUnits(ParseInformation parseInfo)
+		public PythonResolverContext(ParseInformation parseInfo, string fileContent)
+			: this(parseInfo, new ExpressionResult(), fileContent)
 		{
-			compilationUnit = GetCompilationUnit(parseInfo);
 		}
 		
-		ICompilationUnit GetCompilationUnit(ParseInformation parseInfo)
+		public PythonResolverContext(ParseInformation parseInfo, ExpressionResult expressionResult, string fileContent)
+		{
+			this.fileContent = fileContent;
+			this.expressionResult = expressionResult;
+			GetCompilationUnit(parseInfo);
+			GetProjectContent();
+			GetCallingMember();
+		}
+		
+		void GetCompilationUnit(ParseInformation parseInfo)
 		{
 			if (parseInfo != null) {
-				return parseInfo.CompilationUnit;
+				compilationUnit = parseInfo.CompilationUnit;
 			}
-			return null;
 		}
 		
 		void GetProjectContent()
@@ -40,10 +49,56 @@ namespace ICSharpCode.PythonBinding
 			}
 		}
 		
+		/// <summary>
+		/// Determines the class and member at the specified
+		/// line and column in the specified file.
+		/// </summary>
+		void GetCallingMember()
+		{
+			if (projectContent != null) {
+				GetCallingClass();
+			}
+		}
+				
+		/// <summary>
+		/// Gets the calling class at the specified line and column.
+		/// </summary>
+		void GetCallingClass()
+		{
+			if (compilationUnit.Classes.Count > 0) {
+				callingClass = compilationUnit.Classes[0];
+			}
+		}
+		
+		public string FileContent {
+			get { return fileContent; }
+		}
+		
 		public IProjectContent ProjectContent {
 			get { return projectContent; }
 		}
 		
+		public ExpressionResult ExpressionResult {
+			get { return expressionResult; }
+		}
+		
+		public MemberName CreateExpressionMemberName()
+		{
+			return new MemberName(Expression);
+		}
+		
+		public string Expression {
+			get { return expressionResult.Expression; }
+		}
+		
+		public ExpressionContext ExpressionContext {
+			get { return expressionResult.Context; }
+		}
+		
+		public DomRegion ExpressionRegion {
+			get { return expressionResult.Region; }
+		}
+		
 		public bool HasProjectContent {
 			get { return projectContent != null; }
 		}
@@ -81,34 +136,6 @@ namespace ICSharpCode.PythonBinding
 			return false;
 		}
 		
-		/// <summary>
-		/// Determines the class and member at the specified
-		/// line and column in the specified file.
-		/// </summary>
-		public bool GetCallingMember(DomRegion region)
-		{
-			if (compilationUnit == null) {
-				return false;
-			}
-			
-			if (projectContent != null) {
-				callingClass = GetCallingClass(region);
-				return true;
-			}
-			return false;
-		}
-				
-		/// <summary>
-		/// Gets the calling class at the specified line and column.
-		/// </summary>
-		IClass GetCallingClass(DomRegion region)
-		{
-			if (compilationUnit.Classes.Count > 0) {
-				return compilationUnit.Classes[0];
-			}
-			return null;
-		}
-		
 		public IClass GetClass(string fullyQualifiedName)
 		{
 			return projectContent.GetClass(fullyQualifiedName, 0);

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

@@ -8,19 +8,22 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonSelfResolver : IPythonResolver
 	{
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
 			if (resolverContext.HasCallingClass) {
-				if (IsSelfExpression(expressionResult)) {
+				if (IsSelfExpression(resolverContext)) {
 					return CreateResolveResult(resolverContext);
+				} else if (IsSelfExpressionAtStart(resolverContext)) {
+					MemberName memberName = resolverContext.CreateExpressionMemberName();
+					return new PythonMethodGroupResolveResult(resolverContext.CallingClass, memberName.Name);
 				}
 			}
 			return null;
 		}
 		
-		bool IsSelfExpression(ExpressionResult expressionResult)
+		bool IsSelfExpression(PythonResolverContext resolverContext)
 		{
-			return expressionResult.Expression == "self";
+			return resolverContext.Expression == "self";
 		}
 		
 		ResolveResult CreateResolveResult(PythonResolverContext resolverContext)
@@ -29,5 +32,10 @@ namespace ICSharpCode.PythonBinding
 			IReturnType returnType = callingClass.DefaultReturnType;
 			return new ResolveResult(callingClass, null, returnType);
 		}
+		
+		bool IsSelfExpressionAtStart(PythonResolverContext resolverContext)
+		{
+			return resolverContext.Expression.StartsWith("self.");
+		}
 	}
 }

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

@@ -15,9 +15,9 @@ namespace ICSharpCode.PythonBinding
 			this.standardModuleResolver = standardModuleResolver;
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-			MemberName memberName = new MemberName(expressionResult.Expression);
+			MemberName memberName = resolverContext.CreateExpressionMemberName();
 			MethodGroupResolveResult result = ResolveMethodFromImportedNames(resolverContext, memberName);
 			if (result != null) {
 				return result;

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

@@ -10,19 +10,21 @@ namespace ICSharpCode.PythonBinding
 	{
 		PythonStandardModules standardPythonModules = new PythonStandardModules();
 		
-		public PythonStandardModuleResolver()
+		public ResolveResult Resolve(PythonResolverContext resolverContext)
 		{
-		}
+			PythonStandardModuleType type = GetStandardModuleTypeIfImported(resolverContext);
-		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
-		{
-			PythonStandardModuleType type = GetStandardModuleTypeIfImported(resolverContext, expressionResult.Expression);
 			if (type != null) {
 				return new PythonStandardModuleResolveResult(type);
 			}
 			return null;
 		}
 		
+		PythonStandardModuleType GetStandardModuleTypeIfImported(PythonResolverContext resolverContext)
+		{
+			string moduleName = resolverContext.Expression;
+			return GetStandardModuleTypeIfImported(resolverContext, moduleName);
+		}
+		
 		public PythonStandardModuleType GetStandardModuleTypeIfImported(PythonResolverContext resolverContext, string moduleName)
 		{
 			if (resolverContext.HasImport(moduleName) || PythonBuiltInModuleMemberName.IsBuiltInModule(moduleName)) {

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

@@ -83,8 +83,8 @@ namespace ICSharpCode.PythonBinding
 		
 		public ProcessStartInfo CreateProcessStartInfo(SelectedTests selectedTests)
 		{
-			consoleApplication.PythonScriptFileName = GetSharpDevelopTestPythonScriptFileName();
+			consoleApplication.ScriptFileName = GetSharpDevelopTestPythonScriptFileName();
-			consoleApplication.PythonScriptCommandLineArguments = GetResponseFileNameCommandLineArgument();
+			consoleApplication.ScriptCommandLineArguments = GetResponseFileNameCommandLineArgument();
 			consoleApplication.WorkingDirectory = selectedTests.Project.Directory;
 			return consoleApplication.GetProcessStartInfo();
 		}

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

@@ -1,146 +0,0 @@
-// 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 Microsoft.Scripting;
-using Microsoft.Scripting.Hosting;
-using Microsoft.Scripting.Runtime;
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using ICSharpCode.SharpDevelop.Dom;
-using IronPython;
-using IronPython.Compiler;
-using IronPython.Compiler.Ast;
-using IronPython.Runtime;
-using IronPython.Hosting;
-using IronPython.Runtime.Exceptions;
-
-namespace ICSharpCode.PythonBinding
-{
-	/// <summary>
-	/// Determines the type of a variable.
-	/// </summary>
-	public class PythonVariableResolver : PythonWalker
-	{
-		string variableName = String.Empty;
-		string typeName;
-		AssignmentStatement currentAssignStatement;
-		bool foundVariableAssignment;
-		
-		public PythonVariableResolver()
-		{
-		}
-		
-		/// <summary>
-		/// The resolved type name.
-		/// </summary>
-		public string TypeName {
-			get { return typeName; }
-		}
-		
-		/// <summary>
-		/// Resolves the type of the variable name specified.
-		/// </summary>
-		/// <param name="variableName">Name of the variable.</param>
-		/// <param name="code">The python code containing the variable.</param>
-		public string Resolve(string variableName, string fileName, string code)
-		{
-			if (code != null) {
-				ScriptEngine scriptEngine = IronPython.Hosting.Python.CreateEngine();
-				PythonCompilerSink sink = new PythonCompilerSink();
-				SourceUnit source = DefaultContext.DefaultPythonContext.CreateFileUnit(fileName, code);
-				CompilerContext context = new CompilerContext(source, new PythonCompilerOptions(), sink);
-				Parser parser = Parser.CreateParser(context, new PythonOptions());
-				PythonAst ast = parser.ParseFile(false);
-
-				return Resolve(variableName, ast);
-			}
-			return null;
-		}
-				
-		public override bool Walk(AssignmentStatement node)
-		{
-			currentAssignStatement = node;
-			foundVariableAssignment = false;
-			return base.Walk(node);
-		}		
-		
-		public override bool Walk(NameExpression node)
-		{
-			if (currentAssignStatement != null) {
-				string nodeName = node.Name;
-				if (nodeName == variableName) {
-					foundVariableAssignment = true;
-				}
-			}
-			return base.Walk(node);
-		}
-		
-		public override bool Walk(CallExpression node)
-		{
-			if (foundVariableAssignment) {
-				typeName = GetTypeName(node.Target);
-			}
-			return base.Walk(node);
-		}
-		
-		/// <summary>
-		/// Gets the fully qualified name of the type from the expression.
-		/// 
-		/// </summary>
-		/// <remarks>
-		/// The expression is the first target of a call expression.
-		/// 
-		/// A call expression is a method or constructor call (right hand side of expression below):
-		/// 
-		/// a = Root.Test.Class1()
-		/// 
-		/// So the expression passed to this method will be a field expression in the
-		/// above example which refers to Class1. The next target will be a field
-		/// expression referring to Test. The The last target will be a name expression
-		/// referring to Root.
-		/// 
-		/// If we have 
-		/// 
-		/// a = Class1()
-		/// 
-		/// then the expression will be a name expression referring to Class1.
-		/// </remarks>
-		static string GetTypeName(Expression node)
-		{
-			// Collect the names that make up the type name.
-			NameExpression nameExpression = null;
-			List<string> names = new List<string>();
-			do {
-				nameExpression = node as NameExpression;
-				MemberExpression memberExpression = node as MemberExpression;
-				string name = String.Empty;
-				if (memberExpression != null) {
-					name = memberExpression.Name;
-					node = memberExpression.Target;
-				} else if (nameExpression != null) {
-					name = nameExpression.Name;
-				}
-				names.Add(name);
-			} while (nameExpression == null);
-			
-			// Create the fully qualified type name by adding the names
-			// in reverse order.
-			StringBuilder typeName = new StringBuilder();
-			typeName.Append(names[names.Count - 1]);
-			for (int i = names.Count - 2; i >= 0; --i) {
-				typeName.Append('.');
-				typeName.Append(names[i]);
-			}
-			return typeName.ToString();
-		}
-		
-		string Resolve(string variableName, PythonAst ast)
-		{
-			this.variableName = variableName;
-			ast.Walk(this);
-			return TypeName;		
-		}
-	}
-}

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

@@ -2,11 +2,8 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using ICSharpCode.Core;
 using ICSharpCode.Scripting;
 using ICSharpCode.SharpDevelop.Debugging;
-using ICSharpCode.SharpDevelop.Gui;
-using ICSharpCode.SharpDevelop.Util;
 
 namespace ICSharpCode.PythonBinding
 {

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

@@ -2,14 +2,8 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using System.Diagnostics;
-using System.IO;
-
-using ICSharpCode.Core;
 using ICSharpCode.Scripting;
 using ICSharpCode.SharpDevelop.Debugging;
-using ICSharpCode.SharpDevelop.Gui;
-using ICSharpCode.SharpDevelop.Util;
 
 namespace ICSharpCode.PythonBinding
 {
@@ -17,47 +11,16 @@ namespace ICSharpCode.PythonBinding
 	/// Runs the Python console passing the filename of the 
 	/// active python script open in SharpDevelop.
 	/// </summary>
-	public class RunPythonCommand : AbstractMenuCommand
+	public class RunPythonCommand : RunScriptingConsoleApplicationCommand
 	{
-		IDebugger debugger;
-		PythonAddInOptions options;
-		IScriptingWorkbench workbench;
-		PythonConsoleApplication ipy;
-		
 		public RunPythonCommand()
 			: this(new PythonWorkbench(), new PythonAddInOptions(), DebuggerService.CurrentDebugger)
 		{
 		}
 		
 		public RunPythonCommand(IScriptingWorkbench workbench, PythonAddInOptions options, IDebugger debugger)
+			: base(workbench, debugger, new PythonConsoleApplication(options))
 		{
-			this.workbench = workbench;
-			this.debugger = debugger;
-			this.options = options;
-			ipy = new PythonConsoleApplication(options);
-		}
-		
-		public bool Debug {
-			get { return ipy.Debug; }
-			set { ipy.Debug = value; }
-		}
-		
-		public override void Run()
-		{
-			ProcessStartInfo processStartInfo = GetProcessStartInfo();
-			if (Debug) {
-				debugger.Start(processStartInfo);
-			} else {
-				debugger.StartWithoutDebugging(processStartInfo);
-			}
-		}
-		
-		ProcessStartInfo GetProcessStartInfo()
-		{
-			string scriptFileName = workbench.ActiveViewContent.PrimaryFileName;
-			ipy.PythonScriptFileName = scriptFileName;
-			ipy.WorkingDirectory = Path.GetDirectoryName(scriptFileName);
-			return ipy.GetProcessStartInfo();
 		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Completion/NamespaceContentsAddedToCtrlSpaceTestFixture.cs

@@ -36,7 +36,7 @@ namespace PythonBinding.Tests.Resolver
 			namespaceItems.Add(myTestClass);
 			mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);
 			
-			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent) { ErrorsDuringCompile = true };
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
 			
 			// Add usings.
 			DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);

src/AddIns/BackendBindings/Python/PythonBinding/Test/Converter/ProjectHasStartupObjectTestFixture.cs

@@ -65,7 +65,7 @@ namespace PythonBinding.Tests.Converter
 			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
 			MockClass mainClass = new MockClass(mockProjectContent, startupObject);
 			mainClass.CompilationUnit.FileName = @"d:\projects\test\src\Main2.cs";
-			mockProjectContent.ClassToReturnFromGetClass = mainClass;
+			mockProjectContent.SetClassToReturnFromGetClass(startupObject, mainClass);
 			
 			convertProjectCommand = new DerivedConvertProjectToPythonProjectCommand();
 			convertProjectCommand.ProjectContent = mockProjectContent;

src/AddIns/BackendBindings/Python/PythonBinding/Test/Gui/DebugPythonCommandTests.cs

@@ -51,7 +51,7 @@ namespace PythonBinding.Tests.Gui
 		public void Run_PythonFileOpen_DebugOptionsPassedToIronPythonConsole()
 		{
 			string args = debugger.ProcessStartInfo.Arguments;
-			string expectedArgs = "-X:Debug \"C:\\Projects\\test.py\"";
+			string expectedArgs = "-X:Debug \"test.py\"";
 			Assert.AreEqual(expectedArgs, args);
 		}
 	}

src/AddIns/BackendBindings/Python/PythonBinding/Test/Gui/RunPythonCommandTests.cs

@@ -50,18 +50,18 @@ namespace PythonBinding.Tests.Gui
 		}
 		
 		[Test]
-		public void Run_PythonFileOpen_IronPythonConsoleFileNamePassedToDebugger()
+		public void Run_PythonFileOpen_CommandPromptExePassedToDebugger()
 		{
 			string fileName = debugger.ProcessStartInfo.FileName;
-			string expectedFileName = @"C:\IronPython\ipy.exe";
+			string expectedFileName = "cmd.exe";
 			Assert.AreEqual(expectedFileName, fileName);
 		}
 		
 		[Test]
-		public void Run_PythonFileOpen_PythonFileNamePassedToIronPythonConsole()
+		public void Run_PythonFileOpen_IronPythonConsoleAndPythonFileNameAndPausePassedAsCommandLineArguments()
 		{
 			string args = debugger.ProcessStartInfo.Arguments;
-			string expectedArgs = "\"C:\\Projects\\test.py\"";
+			string expectedArgs = "/c \"C:\\IronPython\\ipy.exe \"test.py\"\" & pause";
 			Assert.AreEqual(expectedArgs, args);
 		}
 		

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

@@ -313,7 +313,7 @@
     <Compile Include="Expressions\StringTextContentProviderTests.cs" />
     <Compile Include="Gui\AppSettingsPanelTestFixture.cs" />
     <Compile Include="Gui\CompilingOptionsPanelTestFixture.cs" />
-    <Compile Include="Gui\DebugPythonCommandTestFixture.cs" />
+    <Compile Include="Gui\DebugPythonCommandTests.cs" />
     <Compile Include="Gui\FormsDesignerDisplayBindingTestFixture.cs" />
     <Compile Include="Gui\PythonIndentationTests.cs" />
     <Compile Include="Gui\PythonOptionsPanelTestFixture.cs" />
@@ -348,22 +348,24 @@
     <Compile Include="Resolver\ImportModuleResolveResultTests.cs" />
     <Compile Include="Resolver\InvalidResolveInputsTestFixture.cs" />
     <Compile Include="Resolver\MemberNameTests.cs" />
+    <Compile Include="Resolver\PythonLocalVariableResolverTests.cs" />
     <Compile Include="Resolver\PythonSelfResolverTests.cs" />
-    <Compile Include="Resolver\ResolveBuiltInRoundMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveBuiltInRoundMethodTests.cs" />
-    <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveClassEventTests.cs" />
-    <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
+    <Compile Include="Resolver\ResolveClassFieldTests.cs" />
-    <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTestFixture.cs" />
+    <Compile Include="Resolver\ResolveClassPropertyTests.cs" />
+    <Compile Include="Resolver\ResolveConsoleWriteLineTests.cs" />
+    <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTests.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitTestFixture.cs" />
-    <Compile Include="Resolver\ResolveFooTextBoxFromSystemWindowsFormsImportedAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTests.cs" />
-    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromImportTests.cs" />
-    <Compile Include="Resolver\ResolveFromImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTests.cs" />
-    <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromSystemImportEverythingTests.cs" />
-    <Compile Include="Resolver\ResolveConsoleFromSystemImportEverythingFixture.cs" />
     <Compile Include="Resolver\ResolveImportsTestFixture.cs" />
-    <Compile Include="Resolver\ResolveLocalClassInstanceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveLocalClassInstanceTests.cs" />
-    <Compile Include="Resolver\ResolveMethodFromUnknownImportAllTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodFromUnknownImportAllTests.cs" />
-    <Compile Include="Resolver\ResolveMethodWhenFromImportIsUnknownTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodWhenFromImportIsUnknownTests.cs" />
-    <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTests.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceParseInfoTestFixture.cs" />
     <Compile Include="Resolver\ResolverContextDottedImportedNameMatchTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModulesThatImportEverythingTests.cs" />
@@ -373,28 +375,29 @@
     <Compile Include="Resolver\ResolverContextPartialNamespaceExistsTests.cs" />
     <Compile Include="Resolver\ResolverContextUnaliasImportedModuleNameTestFixture.cs" />
     <Compile Include="Resolver\ResolveSelfTests.cs" />
-    <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleExitMethodTests.cs" />
-    <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTests.cs" />
     <Compile Include="Resolver\ResolveSysModuleTestFixture.cs">
     </Compile>
-    <Compile Include="Resolver\ResolveSysModuleUnknownMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleUnknownMethodTests.cs" />
     <Compile Include="Resolver\ResolveSystemConsoleOutsideClassTestFixture.cs" />
-    <Compile Include="Resolver\ResolveSystemConsoleTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemConsoleTests.cs" />
-    <Compile Include="Resolver\ResolveSystemImportedAsMySystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemImportedAsMySystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemImportTests.cs" />
-    <Compile Include="Resolver\ResolveSystemNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemNamespaceTests.cs" />
-    <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTests.cs" />
-    <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTests.cs" />
-    <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTests.cs" />
-    <Compile Include="Resolver\ResolveTestFixtureBase.cs" />
+    <Compile Include="Resolver\ResolveTestsBase.cs" />
-    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests.cs" />
-    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportTextBoxTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests.cs" />
-    <Compile Include="Resolver\ResolveUnknownNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests.cs" />
+    <Compile Include="Resolver\ResolveUnknownNamespaceTests.cs" />
     <Compile Include="Testing\CreatePythonTestRunnerTestFixture.cs" />
-    <Compile Include="Testing\PythonConsoleApplicationTestFixture.cs" />
+    <Compile Include="Testing\PythonConsoleApplicationTests.cs" />
     <Compile Include="Testing\PythonStandardLibraryPathTests.cs" />
     <Compile Include="Testing\PythonTestDebuggerRunsSelectedTestMethodTestFixture.cs" />
     <Compile Include="Testing\PythonTestFrameworkIsTestClassTests.cs" />
@@ -424,6 +427,7 @@
     <Compile Include="Utils\PythonBindingAddInFile.cs" />
     <Compile Include="Utils\PythonCompletionItemsHelper.cs" />
     <Compile Include="Utils\PythonParserHelper.cs" />
+    <Compile Include="Utils\PythonResolverTestsHelper.cs" />
     <Compile Include="Utils\TestablePythonCodeCompletionBinding.cs" />
     <Compile Include="Utils\TestablePythonCodeCompletionItemProvider.cs" />
     <Compile Include="Utils\Tests\PythonCompletionItemsHelperTests.cs" />

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

@@ -0,0 +1,90 @@
+// 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 IronPython.Compiler.Ast;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class PythonLocalVariableResolverTests
+	{
+		string typeName;
+		
+		void Resolve(string variableName, string code)
+		{
+			PythonClassResolver classResolver = new PythonClassResolver();
+			PythonLocalVariableResolver resolver = new PythonLocalVariableResolver(classResolver);
+			typeName = resolver.Resolve(variableName, code);
+		}
+		
+		[Test]
+		public void Resolve_InstanceCreatedInCode_ReturnsInstanceType()
+		{
+			string code = "a = Class1()";
+			Resolve("a", code);
+			
+			Assert.AreEqual("Class1", typeName);
+		}
+
+		/// <summary>
+		/// Tests that the NameExpression in the resolver is reset so the second assignment
+		/// does not override the first.
+		/// </summary>
+		[Test]
+		public void Resolve_TwoInstancesCreatedInCode_ReturnsFirstInstanceType()
+		{
+			string code = 
+				"a = Class1()\r\n" +
+				"b = Class2()";
+			
+			Resolve("a", code);
+			
+			Assert.AreEqual("Class1", typeName);
+		}
+		
+		[Test]
+		public void Resolve_VariableIsAssignedToString_ReturnsNull()
+		{
+			string code = "a = \"test\"";
+			Resolve("a", code);
+			
+			Assert.IsNull(typeName);
+		}
+		
+		[Test]
+		public void Resolve_CodeIsNull_ReturnsNull()
+		{
+			Resolve("a", null);
+			Assert.IsNull(typeName);
+		}
+		
+		[Test]
+		public void Resolve_InstanceCreatedWithNamespace_ReturnsFullyQualifiedTypeName()
+		{
+			string code = "a = Test.Class1()";
+			Resolve("a", code);
+			Assert.AreEqual("Test.Class1", typeName);
+		}
+		
+		[Test]
+		public void Resolve_InstanceCreatedWithTwoPartsToNamespace_ReturnsFullyQualifiedTypeName()
+		{
+			string code = "a = Root.Test.Class1()";
+			Resolve("a", code);
+			Assert.AreEqual("Root.Test.Class1", typeName);
+		}
+		
+		[Test]
+		public void GetTypeName_ExpressionIsNotNameOrMemberExpression_ReturnsEmptyStringAndDoesNotGetStuckInInfiniteLoop()
+		{
+			AssignmentStatement statement = PythonParserHelper.GetAssignmentStatement("a = 2");
+			Expression expression = statement.Right;
+			string typeName = PythonLocalVariableResolver.GetTypeName(expression);
+			Assert.AreEqual(String.Empty, typeName);
+		}
+	}
+}

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

@@ -24,14 +24,13 @@ namespace PythonBinding.Tests.Resolver
 			CreateParseInfo();
 			CreatePythonResolverContext();
 			
-			ResolveResult result = resolver.Resolve(context, expression);
+			ResolveResult result = resolver.Resolve(context);
 			Assert.IsNull(result);
 		}
 		
 		void CreatePythonSelfResolver()
 		{
 			resolver = new PythonSelfResolver();
-			expression = new ExpressionResult("self");
 		}
 		
 		void CreateParseInfo()
@@ -43,7 +42,8 @@ namespace PythonBinding.Tests.Resolver
 		
 		void CreatePythonResolverContext()
 		{
-			context = new PythonResolverContext(parseInfo);
+			expression = new ExpressionResult("self");
+			context = new PythonResolverContext(parseInfo, expression, String.Empty);
 		}
 	}
 }

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveBuiltInRoundMethodTestFixture : ResolveTestFixtureBase
+	public class ResolveBuiltInRoundMethodTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -0,0 +1,82 @@
+// 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 PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests resolving events for the following classes:
+	/// 
+	/// public class MyClass
+	/// {
+	/// 	public event EventHandler MyEvent;
+	/// }
+	/// 
+	/// </summary>
+	[TestFixture]
+	public class ResolveClassEventTests
+	{
+		PythonResolverTestsHelper resolverHelper;
+		IEvent myClassEvent;
+		MockClass myClass;
+		IProperty eventHandlerTargetProperty;
+		
+		void CreateClassWithOneEvent()
+		{
+			// Define imports.
+			string code = 
+				"from MyNamespace import MyClass";
+			
+			resolverHelper = new PythonResolverTestsHelper(code);
+			myClass = resolverHelper.CreateClass("MyClass");
+			myClassEvent = myClass.AddEvent("MyEvent");
+			
+			AddEventHandlerClass();
+			
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyNamespace.MyClass", myClass);
+		}
+		
+		void AddEventHandlerClass()
+		{
+			MockClass eventHandlerClass = resolverHelper.CreateClass("EventHandler");
+			eventHandlerTargetProperty = eventHandlerClass.AddProperty("Target");
+			myClassEvent.ReturnType = new DefaultReturnType(eventHandlerClass);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForEventOnClass_MemberResolveResultResolvedTypeIsClassEvent()
+		{
+			CreateClassWithOneEvent();
+			resolverHelper.Resolve("MyClass.MyEvent");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassEvent, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForSecondEventOnClass_MemberResolveResultResolvedTypeIsSecondEvent()
+		{
+			CreateClassWithOneEvent();
+			IEvent secondEvent = myClass.AddEvent("SecondEvent");
+			resolverHelper.Resolve("MyClass.SecondEvent");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(secondEvent, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForEventHandlerTargetProperty_MemberResolveResultResolvedTypeIsEventHandlerTargetProperty()
+		{
+			CreateClassWithOneEvent();
+			resolverHelper.Resolve("MyClass.MyEvent.Target");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(eventHandlerTargetProperty, resolvedMember);
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+// 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 PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests resolving events for the following classes:
+	/// 
+	/// public class MyClass
+	/// {
+	/// 	public int MyField
+	/// }
+	/// 
+	/// public class MyClassWithFields
+	/// {
+	/// 	public int MyField = 0;
+	/// }
+	/// 
+	/// </summary>
+	[TestFixture]
+	public class ResolveClassFieldTests
+	{
+		PythonResolverTestsHelper resolverHelper;
+		IField myClassField;
+		MockClass myClass;
+		
+		void CreateClassWithOneEvent()
+		{
+			resolverHelper = new PythonResolverTestsHelper();
+			myClass = resolverHelper.CreateClass("MyClass");
+			myClassField = myClass.AddField("MyField");
+			
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyClass", myClass);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForFieldOnClass_MemberResolveResultResolvedTypeIsClassField()
+		{
+			CreateClassWithOneEvent();
+			resolverHelper.Resolve("MyClass.MyField");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassField, resolvedMember);
+		}
+	}
+}

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

@@ -1,41 +0,0 @@
-// 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 System.Collections;
-using ICSharpCode.PythonBinding;
-using ICSharpCode.SharpDevelop.Dom;
-using NUnit.Framework;
-using PythonBinding.Tests;
-using PythonBinding.Tests.Utils;
-
-namespace PythonBinding.Tests.Resolver
-{
-	/// <summary>
-	/// Given code:
-	/// 
-	/// a = Test.Class1()
-	/// 
-	/// Where Test is the namespace of the class, check that the type of "a" can be obtained 
-	/// by the resolver.
-	/// </summary>
-	[TestFixture]
-	public class ResolveClassInstanceWithNamespaceTestFixture
-	{		
-		[Test]
-		public void GetTypeOfInstance()
-		{
-			string code = "a = Test.Class1()";
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual("Test.Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
-		}
-		
-		[Test]
-		public void GetTypeOfInstanceWithTwoNamespaces()
-		{
-			string code = "a = Root.Test.Class1()";
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual("Root.Test.Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
-		}		
-	}
-}

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

@@ -0,0 +1,84 @@
+// 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 PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests resolving properties for the following classes:
+	/// 
+	/// public class MyClass
+	/// {
+	/// 	public MyNestedPropertyClass MyProperty { get; set; }
+	/// }
+	/// 
+	/// public class MyNestedPropertyClass
+	/// {
+	/// 	public object MyNestedProperty { get; set; }
+	/// }
+	/// 
+	/// </summary>
+	[TestFixture]
+	public class ResolveClassPropertyTests
+	{
+		PythonResolverTestsHelper resolverHelper;
+		IProperty myClassProperty;
+		MockClass myClass;
+		IProperty nestedClassProperty;
+		
+		void CreateClassWithOneProperty()
+		{
+			resolverHelper = new PythonResolverTestsHelper();
+			myClass = resolverHelper.CreateClass("MyClass");
+			myClassProperty = myClass.AddProperty("MyProperty");
+			
+			AddNestedPropertyToExistingProperty();
+			
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyClass", myClass);
+		}
+		
+		void AddNestedPropertyToExistingProperty()
+		{
+			MockClass nestedPropertyClass = resolverHelper.CreateClass("MyNestedPropertyClass");
+			nestedClassProperty = nestedPropertyClass.AddProperty("MyNestedProperty");
+			myClassProperty.ReturnType = new DefaultReturnType(nestedPropertyClass);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty()
+		{
+			CreateClassWithOneProperty();
+			resolverHelper.Resolve("MyClass.MyProperty");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassProperty, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForSecondPropertyOnClassWithTwoProperties_MemberResolveResultResolvedTypeIsSecondClassProperty()
+		{
+			CreateClassWithOneProperty();
+			myClass.InsertPropertyAtStart("ExtraProperty");
+			resolverHelper.Resolve("MyClass.MyProperty");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassProperty, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionRefersToNestedProperty_MemberResolveResultResolvedTypeIsNestedProperty()
+		{
+			CreateClassWithOneProperty();
+			AddNestedPropertyToExistingProperty();
+			resolverHelper.Resolve("MyClass.MyProperty.MyNestedProperty");
+			IMember resolvedMember = resolverHelper.MemberResolveResult.ResolvedMember;
+			
+			Assert.AreEqual(nestedClassProperty, resolvedMember);
+		}
+	}
+}

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

@@ -17,15 +17,14 @@ namespace PythonBinding.Tests.Resolver
 	/// resolved.
 	/// </summary>
 	[TestFixture]
-	public class ResolveConsoleWriteLineTestFixture : ResolveTestFixtureBase
+	public class ResolveConsoleWriteLineTests : ResolveTestsBase
 	{
 		MockClass systemConsoleClass;
 		
 		protected override ExpressionResult GetExpressionResult()
 		{
 			systemConsoleClass = new MockClass(projectContent, "System.Console");
-			projectContent.ClassToReturnFromGetClass = systemConsoleClass;
+			projectContent.SetClassToReturnFromGetClass("Console", systemConsoleClass);
-			projectContent.ClassNameForGetClass = "Console";
 			return new ExpressionResult("Console.WriteLine", new DomRegion(2, 2), null, null);
 		}
 		

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveExitMethodFromSysImportExitAsMyExitTestFixture : ResolveTestFixtureBase
+	public class ResolveExitMethodFromSysImportExitAsMyExitTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveExitMethodFromSysImportExitTestFixture : ResolveTestFixtureBase
+	public class ResolveExitMethodFromSysImportExitTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveFooWindowsWithImportSystemAsFooTestFixture : ResolveTestFixtureBase
+	public class ResolveFooWindowsWithImportSystemAsFooTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -30,7 +30,6 @@ namespace PythonBinding.Tests.Resolver
 			
 			mockProjectContent = new MockProjectContent();
 			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
-			cu.ErrorsDuringCompile = true;
 			cu.FileName = @"C:\Projects\Test\test.py";
 			ParseInformation parseInfo = new ParseInformation(cu);
 					

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

@@ -15,7 +15,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveFromMathImportedMathModuleCompletionItemsTestFixture : ResolveTestFixtureBase
+	public class ResolveFromMathImportedMathModuleCompletionItemsTestFixture : ResolveTestsBase
 	{
 		List<ICompletionEntry> GetCompletionResults()
 		{

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

@@ -14,15 +14,14 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveFromSystemImportEverythingFixture : ResolveTestFixtureBase
+	public class ResolveFromSystemImportEverythingTests : ResolveTestsBase
 	{
 		MockClass consoleClass;
 		
 		protected override ExpressionResult GetExpressionResult()
 		{
 			consoleClass = new MockClass(projectContent, "System.Console");
-			projectContent.ClassToReturnFromGetClass = consoleClass;
+			projectContent.SetClassToReturnFromGetClass("System.Console", consoleClass);
-			projectContent.ClassNameForGetClass = "System.Console";
 			
 			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
 			projectContent.AddExistingNamespaceContents("System", namespaceItems);

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

@@ -1,101 +0,0 @@
-// 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 System.Collections;
-using ICSharpCode.PythonBinding;
-using ICSharpCode.SharpDevelop.Dom;
-using NUnit.Framework;
-using PythonBinding.Tests;
-using PythonBinding.Tests.Utils;
-using UnitTesting.Tests.Utils;
-
-namespace PythonBinding.Tests.Resolver
-{
-	/// <summary>
-	/// Given code:
-	/// 
-	/// a = Class1()
-	/// 
-	/// Check that the type of "a" can be obtained by the resolver.
-	/// </summary>
-	[TestFixture]
-	[Ignore("Disabled local variable resolution for SD 3.0")]
-	public class ResolveLocalClassInstanceTestFixture
-	{
-		PythonResolver resolver;
-		ICSharpCode.Scripting.Tests.Utils.MockProjectContent mockProjectContent;
-		LocalResolveResult resolveResult;
-		MockClass testClass;
-		ICompilationUnit compilationUnit;
-		
-		[TestFixtureSetUp]
-		public void SetUpFixture()
-		{
-			resolver = new PythonResolver();
-			
-			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
-			testClass = new MockClass(mockProjectContent, "Test.Test1");
-			mockProjectContent.ClassesInProjectContent.Add(testClass);			
-			mockProjectContent.ClassToReturnFromGetClass = testClass;
-			mockProjectContent.ClassNameForGetClass = "Test.Test1";
-
-			compilationUnit = new DefaultCompilationUnit(mockProjectContent);
-			compilationUnit.FileName = @"C:\Projects\Test\test.py";
-			ParseInformation parseInfo = new ParseInformation(compilationUnit);
-
-			string python = "a = Test1()\r\n" +
-							"a";
-			ExpressionResult expressionResult = new ExpressionResult("a", new DomRegion(2, 1), null, null);
-			resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as LocalResolveResult;			
-		}		
-		
-		[Test]
-		public void GetTypeOfInstance()
-		{
-			string code = "a = Class1()";
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual("Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
-		}
-
-		/// <summary>
-		/// Tests that the NameExpression in the resolver is reset so the second assignment
-		/// does not override the first.
-		/// </summary>
-		[Test]
-		public void DifferentTypeCreatedLast()
-		{
-			string code = "a = Class1()\r\n" +
-						"b = Class2()";
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual("Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
-		}
-		
-		[Test]
-		public void StringAssignmentShouldNotResolve()
-		{
-			string code = "a = \"test\"";
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual(null, resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
-		}
-		
-		[Test]
-		public void NullCodeShouldNotResolve()
-		{
-			PythonVariableResolver resolver = new PythonVariableResolver();
-			Assert.AreEqual(null, resolver.Resolve("a", @"C:\Projects\Test\Test.py", null));
-		}			
-		
-		[Test]
-		public void ResolveResultIsLocalResolveResult()
-		{
-			Assert.IsNotNull(resolveResult);
-		}
-
-		[Test]
-		public void ResolveResultVariableName()
-		{
-			Assert.AreEqual(resolveResult.VariableName, "a");
-		}
-	}
-}

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

@@ -0,0 +1,180 @@
+// 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 PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Given code:
+	/// 
+	/// a = Class1()
+	/// 
+	/// Check that the type of "a" can be obtained by the resolver.
+	/// </summary>
+	[TestFixture]
+	public class ResolveLocalClassInstanceTests
+	{
+		PythonResolverTestsHelper resolverHelper;
+		MockClass testClass;
+		
+		void CreateResolver()
+		{
+			CreateResolver(String.Empty);
+		}
+		
+		void CreateResolver(string code)
+		{
+			resolverHelper = new PythonResolverTestsHelper(code);
+			
+			testClass = resolverHelper.CreateClass("Test.Test1");
+			resolverHelper.ProjectContent.ClassesInProjectContent.Add(testClass);			
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("Test.Test1", testClass);
+		}
+
+		[Test]
+		public void Resolve_LocalVariableIsCreatedOnPreviousLine_ResolveResultVariableNameIsA()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a";
+			
+			resolverHelper.Resolve("a", python);
+			
+			string name = resolverHelper.LocalResolveResult.VariableName;
+			
+			Assert.AreEqual("a", name);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableIsCreatedOnPreviousLine_ResolveResultResolvedTypeIsTestClass()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a";
+			
+			resolverHelper.Resolve("a", python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(testClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableIsReDefinedAfterLineBeingConsidered_ResolveResultResolvedTypeIsTestClass()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a\r\n" +
+				"a = Unknown.Unknown()\r\n";
+			
+			ExpressionResult expression = new ExpressionResult("a");
+			expression.Region = new DomRegion(
+				beginLine: 2,
+				beginColumn: 0,
+				endLine: 2,
+				endColumn: 1);
+			
+			resolverHelper.Resolve(expression, python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(testClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableIsReDefinedAfterLineBeingConsideredAndExpressionRegionEndLineIsMinusOne_ResolveResultResolvedTypeIsTestClass()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a\r\n" +
+				"a = Unknown.Unknown()\r\n";
+			
+			ExpressionResult expression = new ExpressionResult("a");
+			expression.Region = new DomRegion(
+				beginLine: 2,
+				beginColumn: 0,
+				endLine: -1,
+				endColumn: 1);
+			
+			resolverHelper.Resolve(expression, python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(testClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableTypeIsImported_ResolveResultResolvedTypeDeterminedFromImportedTypes()
+		{
+			string python =
+				"from MyNamespace import MyClass\r\n" +
+				"\r\n" +
+				"a = MyClass()\r\n" +
+				"a";
+			
+			CreateResolver(python);
+			
+			MockClass myClass = resolverHelper.CreateClass("MyNamespace.MyClass");
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyNamespace.MyClass", myClass);
+			
+			resolverHelper.Resolve("a", python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(myClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableMethodIsCalledOnPreviousLine_ResolveResultResolvedTypeIsTestClass()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a.foo()\r\n" + 
+				"a";
+			
+			resolverHelper.Resolve("a", python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(testClass, underlyingClass);
+		}
+		
+		[Test]
+		public void Resolve_LocalVariableMethodIsCalledAfterVariableOnItsOwnOnPreviousLine_ResolveResultResolvedTypeIsTestClass()
+		{
+			CreateResolver();
+			
+			string python =
+				"a = Test.Test1()\r\n" +
+				"a\r\n" +
+				"a.foo()\r\n";
+			
+			resolverHelper.Resolve("a", python);
+			
+			IReturnType resolvedType = resolverHelper.LocalResolveResult.ResolvedType;
+			IClass underlyingClass = resolvedType.GetUnderlyingClass();
+			
+			Assert.AreEqual(testClass, underlyingClass);
+		}
+	}
+}

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveMethodFromUnknownImportAllTestFixture : ResolveTestFixtureBase
+	public class ResolveMethodFromUnknownImportAllTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -12,7 +12,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveMethodWhenFromImportIsUnknownTestFixture : ResolveTestFixtureBase
+	public class ResolveMethodWhenFromImportIsUnknownTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -12,7 +12,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveMethodWhenImportIsUnknownTestFixture : ResolveTestFixtureBase
+	public class ResolveMethodWhenImportIsUnknownTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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 : ResolveTestFixtureBase
+	public class ResolveSelfTests
 	{
 		IClass fooClass;
+		PythonResolverTestsHelper resolverHelper;
 		
-		protected override ExpressionResult GetExpressionResult()
+		void CreateResolver(string code)
 		{
-			fooClass = compilationUnit.Classes[0];
+			resolverHelper = new PythonResolverTestsHelper(code);
-			return new ExpressionResult("self", ExpressionContext.Default);
+			fooClass = resolverHelper.CompilationUnit.Classes[0];
 		}
 		
-		protected override string GetPythonScript()
+		[Test]
+		public void Resolve_ExpressionIsSelf_ResolveResultResolvedTypeUnderlyingClassReturnsFooClass()
 		{
-			return 
+			ResolveSelfExpression();
-				"class Foo(self)\r\n" +
+			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/Resolver/ResolveSysModuleExitMethodTests.cs

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSysModuleExitMethodTestFixture : ResolveTestFixtureBase
+	public class ResolveSysModuleExitMethodTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -11,7 +11,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSysModuleImportedAsMySysTestFixture : ResolveTestFixtureBase
+	public class ResolveSysModuleImportedAsMySysTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -11,7 +11,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSysModuleTestFixture : ResolveTestFixtureBase
+	public class ResolveSysModuleTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -12,7 +12,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSysModuleUnknownMethodTestFixture : ResolveTestFixtureBase
+	public class ResolveSysModuleUnknownMethodTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -34,7 +34,7 @@ namespace PythonBinding.Tests.Resolver
 			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
 			
 			systemConsoleClass = new MockClass(mockProjectContent, "System.Console");
-			mockProjectContent.ClassToReturnFromGetClass = systemConsoleClass;
+			mockProjectContent.SetClassToReturnFromGetClass("System.Console", systemConsoleClass);
 			
 			compilationUnit = CreateCompilationUnit(mockProjectContent);
 			ParseInformation parseInfo = new ParseInformation(compilationUnit);
@@ -67,12 +67,6 @@ namespace PythonBinding.Tests.Resolver
 			Assert.AreEqual(systemConsoleClass, typeResolveResult.ResolvedClass);
 		}
 		
-		[Test]
-		public void IsGetClassCalled()
-		{
-			Assert.IsTrue(mockProjectContent.GetClassCalled);
-		}
-		
 		[Test]
 		public void GetClassName()
 		{

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

@@ -16,7 +16,7 @@ namespace PythonBinding.Tests.Resolver
 	/// a namespace.
 	/// </summary>
 	[TestFixture]
-	public class ResolveSystemImportTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemImportTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -11,7 +11,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSystemImportedAsMySystemTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemImportedAsMySystemTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -39,7 +39,6 @@ namespace PythonBinding.Tests.Resolver
 			PythonParser parser = new PythonParser();
 			string fileName = @"C:\Projects\Test\test.py";
 			DefaultCompilationUnit cu = parser.Parse(mockProjectContent, fileName, python) as DefaultCompilationUnit;
-			cu.ErrorsDuringCompile = true;
 			ParseInformation parseInfo = new ParseInformation(cu);
 			
 			ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(4, 2), null, null);

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

@@ -12,7 +12,7 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSystemNamespaceWithMissingImportTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemNamespaceWithMissingImportTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSystemWindowsFormsWithImportSystemTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemWindowsFormsWithImportSystemTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSystemWindowsWithImportSystemTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemWindowsWithImportSystemTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -12,7 +12,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSystemWithImportSystemWindowsTestFixture : ResolveTestFixtureBase
+	public class ResolveSystemWithImportSystemWindowsTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveTanMethodFromMathImportAllTestFixture : ResolveTestFixtureBase
+	public class ResolveTanMethodFromMathImportAllTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveTanMethodFromMathImportCosAndTanTestFixture : ResolveTestFixtureBase
+	public class ResolveTanMethodFromMathImportCosAndTanTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -10,7 +10,7 @@ using PythonBinding.Tests.Utils;
 
 namespace PythonBinding.Tests.Resolver
 {
-	public abstract class ResolveTestFixtureBase
+	public abstract class ResolveTestsBase
 	{
 		protected ICompilationUnit compilationUnit;
 		protected MockProjectContent projectContent;

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

@@ -14,13 +14,12 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveTextBoxFromSystemWindowsFormsImportTextBoxTestFixture : ResolveTestFixtureBase
+	public class ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{
 			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
-			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
-			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
 			
 			return new ExpressionResult("TextBox", ExpressionContext.Default);
 		}

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

@@ -14,13 +14,12 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveTextBoxFromSystemWindowsFormsImportedAsFooTestFixture : ResolveTestFixtureBase
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{
 			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
-			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
-			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
 			
 			return new ExpressionResult("Foo.TextBox", ExpressionContext.Default);
 		}

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

@@ -14,13 +14,12 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTestFixture : ResolveTestFixtureBase
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{
 			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
-			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
-			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
 			
 			return new ExpressionResult("MyTextBox", ExpressionContext.Default);
 		}

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

@@ -16,7 +16,7 @@ namespace PythonBinding.Tests.Resolver
 	/// an unknown namespace.
 	/// </summary>
 	[TestFixture]
-	public class ResolveUnknownNamespaceTestFixture : ResolveTestFixtureBase
+	public class ResolveUnknownNamespaceTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

src/AddIns/BackendBindings/Python/PythonBinding/Test/Testing/PythonConsoleApplicationTests.cs

@@ -11,7 +11,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Testing
 {
 	[TestFixture]
-	public class PythonConsoleApplicationTestFixture
+	public class PythonConsoleApplicationTests
 	{
 		PythonConsoleApplication app;
 		PythonAddInOptions options;
@@ -25,44 +25,48 @@ namespace PythonBinding.Tests.Testing
 		}
 		
 		[Test]
-		public void FileNameIsPythonFileNameFromAddInOptions()
+		public void FileName_NewInstance_FileNameIsPythonFileNameFromAddInOptions()
 		{
+			string fileName = app.FileName;
 			string expectedFileName = @"C:\IronPython\ipy.exe";
-			Assert.AreEqual(expectedFileName, app.FileName);
+			Assert.AreEqual(expectedFileName, fileName);
 		}
 		
 		[Test]
-		public void GetArgumentsReturnsDebugOptionWhenDebugIsTrue()
+		public void GetArguments_DebugIsTrue_ReturnsDebugOption()
 		{
 			app.Debug = true;
+			string args = app.GetArguments();
 			string expectedCommandLine = "-X:Debug";
 			
-			Assert.AreEqual(expectedCommandLine, app.GetArguments());
+			Assert.AreEqual(expectedCommandLine, args);
 		}
 		
 		[Test]
-		public void GetArgumentsReturnsQuotedPythonScriptFileName()
+		public void GetArguments_ScriptFileNameSet_ReturnsQuotedPythonScriptFileName()
 		{
-			app.PythonScriptFileName = @"d:\projects\my ipy\test.py";
+			app.ScriptFileName = @"d:\projects\my ipy\test.py";
+			string args = app.GetArguments();
 			string expectedCommandLine = "\"d:\\projects\\my ipy\\test.py\"";
 			
-			Assert.AreEqual(expectedCommandLine, app.GetArguments());
+			Assert.AreEqual(expectedCommandLine, args);
 		}
 		
 		[Test]
-		public void GetArgumentsReturnsQuotedPythonScriptFileNameAndItsCommandLineArguments()
+		public void GetArguments_ScriptFileNameAndScriptCommandLineArgsSet_ReturnsQuotedPythonScriptFileNameAndItsCommandLineArguments()
 		{
 			app.Debug = true;
-			app.PythonScriptFileName = @"d:\projects\my ipy\test.py";
+			app.ScriptFileName = @"d:\projects\my ipy\test.py";
-			app.PythonScriptCommandLineArguments = "@responseFile.txt -def";
+			app.ScriptCommandLineArguments = "@responseFile.txt -def";
+			string args = app.GetArguments();
 			string expectedCommandLine =
 				"-X:Debug \"d:\\projects\\my ipy\\test.py\" @responseFile.txt -def";
 			
-			Assert.AreEqual(expectedCommandLine, app.GetArguments());
+			Assert.AreEqual(expectedCommandLine, args);
 		}
 		
 		[Test]
-		public void GetProcessStartInfoHasFileNameThatEqualsIronPythonConsoleApplicationExeFileName()
+		public void GetProcessStartInfo_NewInstance_ReturnsProcessStartInfoWithFileNameThatEqualsIronPythonConsoleApplicationExeFileName()
 		{
 			ProcessStartInfo startInfo = app.GetProcessStartInfo();
 			string expectedFileName = @"C:\IronPython\ipy.exe";
@@ -71,7 +75,7 @@ namespace PythonBinding.Tests.Testing
 		}
 		
 		[Test]
-		public void GetProcessStartInfoHasDebugFlagSetInArguments()
+		public void GetProcessStartInfo_DebugIsTrue_ReturnsProcessStartInfoWithDebugFlagSetInArguments()
 		{
 			app.Debug = true;
 			ProcessStartInfo startInfo = app.GetProcessStartInfo();
@@ -81,20 +85,21 @@ namespace PythonBinding.Tests.Testing
 		}
 		
 		[Test]
-		public void GetProcessStartInfoHasWorkingDirectoryIfSet()
+		public void GetProcessStartInfo_WorkingDirectorySet_ReturnsProcessStartInfoWithMatchingWorkingDirectory()
 		{
 			app.WorkingDirectory = @"d:\temp";
 			ProcessStartInfo startInfo = app.GetProcessStartInfo();
-			Assert.AreEqual(@"d:\temp", startInfo.WorkingDirectory);
+			string expectedDirectory = @"d:\temp";
+			Assert.AreEqual(expectedDirectory, startInfo.WorkingDirectory);
 		}
 		
 		[Test]
-		public void ChangingOptionsPythonFileNameChangesProcessStartInfoFileName()
+		public void GetProcessStartInfo_ChangingPythonOptionsFileName_ProcessStartInfoFileNameMatchesChange()
 		{
 			options.PythonFileName = @"d:\temp\test\ipy.exe";
 			ProcessStartInfo startInfo = app.GetProcessStartInfo();
-			
+			string expectedFileName = @"d:\temp\test\ipy.exe";
-			Assert.AreEqual(@"d:\temp\test\ipy.exe", startInfo.FileName);
+			Assert.AreEqual(expectedFileName, startInfo.FileName);
 		}
 	}
 }

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

@@ -1,9 +1,5 @@
-// <file>
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-//     <copyright see="prj:///doc/copyright.txt"/>
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
-//     <version>$Revision$</version>
-// </file>
 
 using System;
 using ICSharpCode.PythonBinding;

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

@@ -1,9 +1,5 @@
-// <file>
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-//     <copyright see="prj:///doc/copyright.txt"/>
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
-//     <version>$Revision$</version>
-// </file>
 
 using System;
 using ICSharpCode.PythonBinding;

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

@@ -0,0 +1,73 @@
+// 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.SharpDevelop.Dom;
+using UnitTesting.Tests.Utils;
+using ScriptingUtils = ICSharpCode.Scripting.Tests.Utils;
+
+namespace PythonBinding.Tests.Utils
+{
+	public class PythonResolverTestsHelper
+	{
+		public ScriptingUtils.MockProjectContent ProjectContent;
+		public	DefaultCompilationUnit CompilationUnit;
+		public ParseInformation ParseInfo;
+		public PythonResolver Resolver;
+		public ResolveResult ResolveResult;
+		
+		public PythonResolverTestsHelper(string code)
+		{
+			ProjectContent = new ScriptingUtils.MockProjectContent();
+			PythonParser parser = new PythonParser();
+			string fileName = @"test.py";
+			CompilationUnit = parser.Parse(ProjectContent, fileName, code) as DefaultCompilationUnit;
+			
+			ParseInfo = new ParseInformation(CompilationUnit);			
+			Resolver = new PythonResolver();
+		}
+		
+		public PythonResolverTestsHelper()
+			: this(String.Empty)
+		{
+		}
+		
+		public ResolveResult Resolve(string expression)
+		{
+			ExpressionResult expressionResult = new ExpressionResult(expression);
+			PythonResolverContext context = new PythonResolverContext(ParseInfo, expressionResult, String.Empty);
+			ResolveResult = Resolver.Resolve(context);
+			return ResolveResult;
+		}
+		
+		public ResolveResult Resolve(string expression, string code)
+		{
+			ExpressionResult expressionResult = new ExpressionResult(expression);
+			return Resolve(expressionResult, code);
+		}
+		
+		public ResolveResult Resolve(ExpressionResult expressionResult, string code)
+		{
+			ResolveResult = Resolver.Resolve(expressionResult, ParseInfo, code);
+			return ResolveResult;
+		}
+		
+		public MemberResolveResult MemberResolveResult {
+			get { return ResolveResult as MemberResolveResult; }
+		}
+		
+		public LocalResolveResult LocalResolveResult {
+			get { return ResolveResult as LocalResolveResult; }
+		}
+		
+		public MethodGroupResolveResult MethodGroupResolveResult {
+			get { return ResolveResult as MethodGroupResolveResult; }
+		}
+		
+		public MockClass CreateClass(string name)
+		{
+			return new MockClass(ProjectContent, name);
+		}
+	}
+}

src/AddIns/BackendBindings/Ruby/RubyBinding.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.0.0.6511
+# SharpDevelop 4.0.0.6676
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RubyBinding", "RubyBinding\Project\RubyBinding.csproj", "{C896FFFF-5B6C-4B0E-B6DF-049865F501B4}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RubyBinding.Tests", "RubyBinding\Test\RubyBinding.Tests.csproj", "{01DF0475-0CB2-4E81-971B-BADC60CDE3A5}"

src/AddIns/BackendBindings/Ruby/RubyBinding/Project/RubyBinding.csproj

@@ -13,6 +13,8 @@
     <NoStdLib>False</NoStdLib>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
     <OutputPath>..\..\..\..\..\..\AddIns\BackendBindings\RubyBinding\</OutputPath>

src/AddIns/BackendBindings/Ruby/RubyBinding/Project/Src/RubyConsoleApplication.cs

@@ -6,110 +6,41 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text;
 
+using ICSharpCode.Scripting;
+
 namespace ICSharpCode.RubyBinding
 {
-	public class RubyConsoleApplication
+	public class RubyConsoleApplication : ScriptingConsoleApplication
 	{
 		RubyAddInOptions options;
-		bool debug;
 		List<string> loadPaths = new List<string>();
-		string rubyScriptFileName = String.Empty;
-		string rubyScriptCommandLineArguments = String.Empty;
-		string workingDirectory = String.Empty;
-		string loadPath = String.Empty;
-		StringBuilder arguments;
 		
 		public RubyConsoleApplication(RubyAddInOptions options)
 		{
 			this.options = options;
 		}
 		
-		public string FileName {
+		public override string FileName {
 			get { return options.RubyFileName; }
 		}
 		
-		public bool Debug {
-			get { return debug; }
-			set { debug = value; }
-		}
-		
 		public void AddLoadPath(string path)
 		{
 			loadPaths.Add(path);
 		}
 		
-		public string RubyScriptFileName {
+		protected override void AddArguments(ScriptingCommandLineBuilder commandLine)
-			get { return rubyScriptFileName; }
-			set { rubyScriptFileName = value; }
-		}
-		
-		public string RubyScriptCommandLineArguments {
-			get { return rubyScriptCommandLineArguments; }
-			set { rubyScriptCommandLineArguments = value; }
-		}
-		
-		public string WorkingDirectory {
-			get { return workingDirectory; }
-			set { workingDirectory = value; }
-		}
-		
-		public ProcessStartInfo GetProcessStartInfo()
-		{
-			ProcessStartInfo processStartInfo = new ProcessStartInfo();
-			processStartInfo.FileName = FileName;
-			processStartInfo.Arguments = GetArguments();
-			processStartInfo.WorkingDirectory = workingDirectory;
-			return processStartInfo;
-		}
-		
-		public string GetArguments()
-		{
-			arguments = new StringBuilder();
-			
-			AppendBooleanOptionIfTrue("-D", debug);
-			AppendLoadPaths();
-			AppendQuotedStringIfNotEmpty(rubyScriptFileName);
-			AppendStringIfNotEmpty(rubyScriptCommandLineArguments);
-			
-			return arguments.ToString().TrimEnd();
-		}
-		
-		void AppendBooleanOptionIfTrue(string option, bool flag)
 		{
-			if (flag) {
+			commandLine.AppendBooleanOptionIfTrue("-D", Debug);
-				AppendOption(option);
+			AppendLoadPaths(commandLine);
-			}
+			commandLine.AppendQuotedStringIfNotEmpty(ScriptFileName);
-		}
+			commandLine.AppendStringIfNotEmpty(ScriptCommandLineArguments);
-		
-		void AppendOption(string option)
-		{
-			arguments.Append(option + " ");
 		}
 		
-		void AppendLoadPaths()
+		void AppendLoadPaths(ScriptingCommandLineBuilder commandLine)
 		{
 			foreach (string path in loadPaths) {
-				AppendQuotedString("-I" + path);
+				commandLine.AppendQuotedString("-I" + path);
-			}
-		}
-		
-		void AppendQuotedStringIfNotEmpty(string option)
-		{
-			if (!String.IsNullOrEmpty(option)) {
-				AppendQuotedString(option);
-			}
-		}
-		
-		void AppendQuotedString(string option)
-		{
-			string quotedOption = String.Format("\"{0}\"", option);
-			AppendOption(quotedOption);
-		}
-		
-		void AppendStringIfNotEmpty(string option)
-		{
-			if (!String.IsNullOrEmpty(option)) {
-				AppendOption(option);
 			}
 		}
 	}

src/AddIns/BackendBindings/Ruby/RubyBinding/Project/Src/RubyTestRunnerApplication.cs

@@ -66,9 +66,9 @@ namespace ICSharpCode.RubyBinding
 		
 		public ProcessStartInfo CreateProcessStartInfo(SelectedTests selectedTests)
 		{
-			consoleApplication.RubyScriptFileName = GetSharpDevelopTestRubyScriptFileName();
+			consoleApplication.ScriptFileName = GetSharpDevelopTestRubyScriptFileName();
 			AddLoadPaths(selectedTests.Project);
-			consoleApplication.RubyScriptCommandLineArguments = GetCommandLineArguments(selectedTests);
+			consoleApplication.ScriptCommandLineArguments = GetCommandLineArguments(selectedTests);
 			consoleApplication.WorkingDirectory = selectedTests.Project.Directory;
 			return consoleApplication.GetProcessStartInfo();
 		}
@@ -84,7 +84,7 @@ namespace ICSharpCode.RubyBinding
 			if (options.HasRubyLibraryPath) {
 				consoleApplication.AddLoadPath(options.RubyLibraryPath);
 			}
-			string testRunnerLoadPath = Path.GetDirectoryName(consoleApplication.RubyScriptFileName);
+			string testRunnerLoadPath = Path.GetDirectoryName(consoleApplication.ScriptFileName);
 			consoleApplication.AddLoadPath(testRunnerLoadPath);
 		}
 		

src/AddIns/BackendBindings/Ruby/RubyBinding/Project/Src/RunRubyCommand.cs

@@ -17,70 +17,16 @@ namespace ICSharpCode.RubyBinding
 	/// Runs the Ruby console passing the filename of the 
 	/// active Ruby script open in SharpDevelop.
 	/// </summary>
-	public class RunRubyCommand : AbstractMenuCommand
+	public class RunRubyCommand : RunScriptingConsoleApplicationCommand
-	{
+	{		
-		IDebugger debugger;
-		RubyAddInOptions options;
-		IScriptingWorkbench workbench;
-		bool debug;
-		
 		public RunRubyCommand()
 			: this(new RubyWorkbench(), new RubyAddInOptions(), DebuggerService.CurrentDebugger)
 		{
 		}
 		
 		public RunRubyCommand(IScriptingWorkbench workbench, RubyAddInOptions options, IDebugger debugger)
+			: base(workbench, debugger, new RubyConsoleApplication(options))
 		{
-			this.workbench = workbench;
-			this.debugger = debugger;
-			this.options = options;
-		}
-		
-		public bool Debug {
-			get { return debug; }
-			set { debug = value; }
-		}
-		
-		public override void Run()
-		{
-			if (debug) {
-				debugger.Start(CreateProcessStartInfo());
-			} else {
-				debugger.StartWithoutDebugging(CreateProcessStartInfo());
-			}
-		}
-		
-		ProcessStartInfo CreateProcessStartInfo()
-		{
-			ProcessStartInfo info = new ProcessStartInfo();
-			info.FileName = options.RubyFileName;
-			info.Arguments = GetArguments();
-			info.WorkingDirectory = GetWorkingDirectory();
-				
-			return info;
-		}
-		
-		string GetWorkingDirectory()
-		{
-			return Path.GetDirectoryName(WorkbenchPrimaryFileName);
-		}
-		
-		FileName WorkbenchPrimaryFileName {
-			get { return workbench.ActiveViewContent.PrimaryFileName; }
-		}
-		
-		string GetArguments()
-		{
-			string args = GetRubyScriptFileName();			
-			if (Debug) {
-				return "-D " + args;
-			}
-			return args;
-		}
-		
-		string GetRubyScriptFileName()
-		{
-			return Path.GetFileName(WorkbenchPrimaryFileName);
 		}
 	}
 }

src/AddIns/BackendBindings/Ruby/RubyBinding/Test/Gui/DebugRunRubyCommandTests.cs

@@ -13,13 +13,13 @@ using RubyBinding.Tests.Utils;
 namespace RubyBinding.Tests.Gui
 {
 	[TestFixture]
-	public class DebugRubyCommandTestFixture
+	public class DebugRubyCommandTests
 	{
 		MockDebugger debugger;
 		RunDebugRubyCommand command;
 		
-		[TestFixtureSetUp]
+		[SetUp]
-		public void SetUpFixture()
+		public void Init()
 		{
 			MockWorkbench workbench = MockWorkbench.CreateWorkbenchWithOneViewContent(@"C:\Projects\test.rb");
 
@@ -33,21 +33,28 @@ namespace RubyBinding.Tests.Gui
 		}
 				
 		[Test]
-		public void DebuggerStartMethodCalled()
+		public void Run_RubyFileOpen_DebuggerStartMethodCalled()
 		{
-			Assert.IsTrue(debugger.StartMethodCalled);
+			bool startMethodCalled = debugger.StartMethodCalled;
+			Assert.IsTrue(startMethodCalled);
 		}
 		
 		[Test]
-		public void ProcessInfoFileNameContainsPathToIronRubyConsole()
+		public void Run_RubyFileOpen_ProcessInfoFileNameContainsPathToIronRubyConsole()
 		{
-			Assert.AreEqual(@"C:\IronRuby\ir.exe", debugger.ProcessStartInfo.FileName);
+			string fileName = debugger.ProcessStartInfo.FileName;
+			string expectedFileName = @"C:\IronRuby\ir.exe";
+			
+			Assert.AreEqual(expectedFileName, fileName);
 		}
 		
 		[Test]
-		public void ProcessInfoArgsHasDebugArgument()
+		public void Run_RubyFileOpen_ProcessInfoArgsHasDebugArgument()
 		{
-			Assert.AreEqual("-D test.rb", debugger.ProcessStartInfo.Arguments);
+			string arguments = debugger.ProcessStartInfo.Arguments;
+			string expectedArguments = "-D \"test.rb\"";
+			
+			Assert.AreEqual(expectedArguments, arguments);
 		}
 	}
 }

src/AddIns/BackendBindings/Ruby/RubyBinding/Test/Gui/RunRubyCommandTests.cs

@@ -22,8 +22,8 @@ namespace RubyBinding.Tests.Gui
 		MockDebugger debugger;
 		RunRubyCommand command;
 		
-		[TestFixtureSetUp]
+		[SetUp]
-		public void SetUpFixture()
+		public void Init()
 		{
 			MockWorkbench workbench = MockWorkbench.CreateWorkbenchWithOneViewContent(@"C:\Projects\test.rb");
 
@@ -37,33 +37,42 @@ namespace RubyBinding.Tests.Gui
 		}
 		
 		[Test]
-		public void RunRubyCommandIsAbstractCommand()
+		public void Run_RubyFileOpen_RubyCommandIsAbstractCommand()
 		{
-			Assert.IsNotNull(command as AbstractCommand);
+			AbstractCommand abstractCommand = command as AbstractCommand;
+			Assert.IsNotNull(abstractCommand);
 		}
 		
 		[Test]
-		public void DebuggerStartWithoutDebuggingMethodCalled()
+		public void Run_RubyFileOpen_DebuggerStartWithoutDebuggingMethodCalled()
 		{
-			Assert.IsTrue(debugger.StartWithoutDebuggingMethodCalled);
+			bool startCalled = debugger.StartWithoutDebuggingMethodCalled;
+			Assert.IsTrue(startCalled);
 		}
 		
 		[Test]
-		public void ProcessInfoFileNameIsIronRubyConsole()
+		public void Run_RubyFileOpen_ProcessInfoFileNameIsIronRubyConsole()
 		{
-			Assert.AreEqual(@"C:\IronRuby\ir.exe", debugger.ProcessStartInfo.FileName);
+			string fileName = debugger.ProcessStartInfo.FileName;
+			string expectedFileName = "cmd.exe";
+			Assert.AreEqual(expectedFileName, fileName);
 		}
 		
 		[Test]
-		public void ProcessInfoArgsContainsFileNameActiveInTextEditor()
+		public void Run_RubyFileOpen_ProcessInfoArgsContainsFileNameActiveInTextEditor()
 		{
-			Assert.AreEqual("test.rb", debugger.ProcessStartInfo.Arguments);
+			string arguments = debugger.ProcessStartInfo.Arguments;
+			string expectedArguments = "/c \"C:\\IronRuby\\ir.exe \"test.rb\"\" & pause";
+			
+			Assert.AreEqual(expectedArguments, arguments);
 		}
 		
 		[Test]
-		public void WorkingDirectoryIsSameDirectoryAsFileBeingRun()
+		public void Run_RubyFileOpen_WorkingDirectoryIsSameDirectoryAsFileBeingRun()
 		{
-			Assert.AreEqual(@"C:\Projects", debugger.ProcessStartInfo.WorkingDirectory);
+			string directory = debugger.ProcessStartInfo.WorkingDirectory;
+			string expectedDirectory = @"C:\Projects";
+			Assert.AreEqual(expectedDirectory, directory);
 		}
 	}
 }