Merge python addin to trunk and use IronPython 2.6.1 RC1 for .NET 4.0 RC1

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@5520 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

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

@@ -12,6 +12,7 @@
 	<Runtime>
 		<Import assembly=":ICSharpCode.SharpDevelop"/>
 		<Import assembly="$ICSharpCode.FormsDesigner/FormsDesigner.dll"/>
+		<Import assembly="IronPython.Modules.dll"/>
 		<Import assembly="PythonBinding.dll"/>
 	</Runtime>
 	

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

@@ -12,36 +12,95 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonClassResolver : IPythonResolver
 	{
+		PythonResolverContext resolverContext;
+		
 		public PythonClassResolver()
 		{
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext context, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
 		{
-			IClass matchingClass = GetClass(context, expressionResult.Expression);
+			IClass matchingClass = GetClass(resolverContext, expressionResult.Expression);
 			if (matchingClass != null) {
 				return CreateTypeResolveResult(matchingClass);
 			}
 			return null;
 		}
 		
-		public IClass GetClass(PythonResolverContext context, string name)
+		public IClass GetClass(PythonResolverContext resolverContext, string name)
 		{
+			this.resolverContext = resolverContext;
+			
 			if (String.IsNullOrEmpty(name)) {
 				return null;
 			}
 			
-			IClass matchedClass = context.GetClass(name);
+			IClass matchedClass = resolverContext.GetClass(name);
+			if (matchedClass != null) {
+				return matchedClass;
+			}
+			
+			matchedClass = GetClassFromImportedNames(name);
+			if (matchedClass != null) {
+				return matchedClass;
+			}
+			
+			matchedClass = GetClassFromNamespaceThatImportsEverything(name);
 			if (matchedClass != null) {
 				return matchedClass;
 			}
 			
-			return context.GetImportedClass(name);
+			return GetClassFromDottedImport(name);
 		}
 		
 		TypeResolveResult CreateTypeResolveResult(IClass c)
 		{
 			return new TypeResolveResult(null, null, c);
 		}
+		
+		IClass GetClassFromImportedNames(string name)
+		{
+			string moduleName = resolverContext.GetModuleForImportedName(name);
+			if (moduleName != null) {
+				name = resolverContext.UnaliasImportedName(name);
+				string fullyQualifiedName = GetQualifiedClassName(moduleName, name);
+				return resolverContext.GetClass(fullyQualifiedName);
+			}
+			return null;
+		}
+		
+		string GetQualifiedClassName(string namespacePrefix, string className)
+		{
+			return namespacePrefix + "." + className;
+		}
+		
+		IClass GetClassFromNamespaceThatImportsEverything(string name)
+		{
+			foreach (string moduleName in resolverContext.GetModulesThatImportEverything()) {
+				string fullyQualifiedName = GetQualifiedClassName(moduleName, name);
+				IClass matchedClass = resolverContext.GetClass(fullyQualifiedName);
+				if (matchedClass != null) {
+					return matchedClass;
+				}
+			}
+			return null;
+		}
+		
+		IClass GetClassFromDottedImport(string name)
+		{
+			string moduleName = resolverContext.FindStartOfDottedModuleNameInImports(name);
+			if (moduleName != null) {
+				string fullyQualifiedName = UnaliasClassName(moduleName, name);
+				return resolverContext.GetClass(fullyQualifiedName);
+			}
+			return null;
+		}
+		
+		string UnaliasClassName(string moduleName, string fullClassName)
+		{
+			string actualModuleName = resolverContext.UnaliasImportedModuleName(moduleName);
+			string lastPartOfClassName = fullClassName.Substring(moduleName.Length + 1);
+			return GetQualifiedClassName(actualModuleName, lastPartOfClassName);
+		}
 	}
 }

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

@@ -77,9 +77,7 @@ namespace ICSharpCode.PythonBinding
 		{
 			classDefinition = node;
 			componentName = node.Name;
-			if (node.Body != null) {
-				node.Body.Walk(this);
-			}
+			node.Body.Walk(this);
 			return false;
 		}
 				

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

@@ -20,6 +20,10 @@ namespace ICSharpCode.PythonBinding
 		
 		protected override int SmartIndentLine(TextArea textArea, int line)
 		{
+			if (line == 0) {
+				return base.SmartIndentLine(textArea, line);
+			}
+			
 			IDocument document = textArea.Document;
 			LineSegment previousLine = document.GetLineSegment(line - 1);
 			string previousLineText = document.GetText(previousLine).Trim();

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

@@ -27,5 +27,9 @@ namespace ICSharpCode.PythonBinding
 		public override CodeDomProvider CodeDomProvider {
 			get { return new CSharpCodeProvider(); }
 		}
+		
+		public override bool AllowObjectConstructionOutsideContext {
+			get { return true; }
+		}
 	}
 }

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

@@ -12,17 +12,61 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonNamespaceResolver : IPythonResolver
 	{
+		PythonResolverContext resolverContext;
+		ExpressionResult expressionResult;
+		
 		public PythonNamespaceResolver()
 		{
 		}
 		
 		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			this.resolverContext = resolverContext;
+			this.expressionResult = expressionResult;
+			
+			if (resolverContext.HasImport(expressionResult.Expression)) {
+				return ResolveFullNamespace();
+			}
+			return ResolvePartialNamespaceMatch();
+		}
+			
+		ResolveResult ResolveFullNamespace()
 		{
 			string actualNamespace = resolverContext.UnaliasImportedModuleName(expressionResult.Expression);
-			if (resolverContext.NamespaceExists(actualNamespace)) {
-				return new NamespaceResolveResult(null, null, actualNamespace);
+			return ResolveIfNamespaceExistsInProjectReferences(actualNamespace);
+		}	
+		
+		ResolveResult ResolvePartialNamespaceMatch()
+		{
+			string fullNamespace = expressionResult.Expression;
+			if (resolverContext.IsStartOfDottedModuleNameImported(fullNamespace)) {
+				return ResolveIfPartialNamespaceExistsInProjectReferences(fullNamespace);
+			} else if (resolverContext.HasDottedImportNameThatStartsWith(fullNamespace)) {
+				return CreateNamespaceResolveResult(fullNamespace);
 			}
 			return null;
 		}
+		
+		ResolveResult ResolveIfNamespaceExistsInProjectReferences(string namespaceName)
+		{
+			if (resolverContext.NamespaceExistsInProjectReferences(namespaceName)) {
+				return CreateNamespaceResolveResult(namespaceName);
+			}
+			return null;
+		}
+		
+		ResolveResult ResolveIfPartialNamespaceExistsInProjectReferences(string namespaceName)
+		{
+			string actualNamespace = resolverContext.UnaliasStartOfDottedImportedModuleName(namespaceName);
+			if (resolverContext.PartialNamespaceExistsInProjectReferences(actualNamespace)) {
+				return CreateNamespaceResolveResult(actualNamespace);
+			}
+			return null;
+		}
+		
+		ResolveResult CreateNamespaceResolveResult(string namespaceName)
+		{
+			return new NamespaceResolveResult(null, null, namespaceName);
+		}
 	}
 }

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

@@ -54,11 +54,31 @@ namespace ICSharpCode.PythonBinding
 			get { return callingClass; }
 		}
 		
-		public bool NamespaceExists(string name)
+		public bool NamespaceExistsInProjectReferences(string name)
 		{
 			return projectContent.NamespaceExists(name);
 		}
 		
+		public bool PartialNamespaceExistsInProjectReferences(string name)
+		{
+			foreach (IProjectContent referencedContent in projectContent.ReferencedContents) {
+				if (PartialNamespaceExists(referencedContent, name)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		bool PartialNamespaceExists(IProjectContent projectContent, string name)
+		{
+			foreach (string namespaceReference in projectContent.NamespaceNames) {
+				if (namespaceReference.StartsWith(name)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
 		/// <summary>
 		/// Determines the class and member at the specified
 		/// line and column in the specified file.
@@ -158,7 +178,7 @@ namespace ICSharpCode.PythonBinding
 		/// <param name="name">The unqualified class name.</param>
 		public IClass GetImportedClass(string name)
 		{
-			foreach (Object obj in GetImportedTypes()) {
+			foreach (object obj in GetImportedTypes()) {
 				IClass c = obj as IClass;
 				if ((c != null) && IsSameClassName(name, c.Name)) {
 					return c;
@@ -238,5 +258,51 @@ namespace ICSharpCode.PythonBinding
 			}
 			return modules.ToArray();
 		}
+		
+		public bool IsStartOfDottedModuleNameImported(string fullDottedModuleName)
+		{
+			return FindStartOfDottedModuleNameInImports(fullDottedModuleName) != null;
+		}
+		
+		public string FindStartOfDottedModuleNameInImports(string fullDottedModuleName)
+		{
+			MemberName memberName = new MemberName(fullDottedModuleName);
+			while (memberName.HasName) {
+				string partialNamespace = memberName.Type;
+				if (HasImport(partialNamespace)) {
+					return partialNamespace;
+				}
+				memberName = new MemberName(partialNamespace);
+			}
+			return null;
+		}
+		
+		public string UnaliasStartOfDottedImportedModuleName(string fullDottedModuleName)
+		{
+			string startOfModuleName = FindStartOfDottedModuleNameInImports(fullDottedModuleName);
+			if (startOfModuleName != null) {
+				return UnaliasStartOfDottedImportedModuleName(startOfModuleName, fullDottedModuleName);
+			}
+			return fullDottedModuleName;
+		}
+		
+		string UnaliasStartOfDottedImportedModuleName(string startOfModuleName, string fullModuleName)
+		{
+			string unaliasedStartOfModuleName = UnaliasImportedModuleName(startOfModuleName);
+			return unaliasedStartOfModuleName + fullModuleName.Substring(startOfModuleName.Length);
+		}
+		
+		public bool HasDottedImportNameThatStartsWith(string importName)
+		{
+			string dottedImportNameStartsWith = importName + ".";
+			foreach (IUsing u in mostRecentCompilationUnit.UsingScope.Usings) {
+				foreach (string ns in u.Usings) {
+					if (ns.StartsWith(dottedImportNameStartsWith)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/MissingInitializeComponentMethodTestFixture.cs

@@ -48,14 +48,22 @@ namespace PythonBinding.Tests.Designer
 		}
 		
 		/// <summary>
-		/// Check that the PythonFormWalker does not try to walk the class body if it is null.
+		/// Check that the PythonComponentWalker does not try to walk the class body if it is null.
+		/// IronPython 2.6.1 now throws an ArgumentNullException if null is passed for the 
+		/// class body.
 		/// </summary>
 		[Test]
-		public void ClassWithNoBody()
+		public void ClassWithNoBodyCannotBeCreated()
+		{
+			ArgumentNullException ex = 
+				Assert.Throws<ArgumentNullException>(delegate { CreateClassWithNullBody(); });
+			
+			Assert.AreEqual("body", ex.ParamName);
+		}
+		
+		void CreateClassWithNullBody()
 		{
 			ClassDefinition classDef = new ClassDefinition("classWithNoBody", null, null);
-			PythonComponentWalker walker = new PythonComponentWalker(this);
-			walker.Walk(classDef);
 		}
 		
 		/// <summary>

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

@@ -372,22 +372,26 @@
     <Compile Include="Resolver\MemberNameTests.cs" />
     <Compile Include="Resolver\ResolveBuiltInRoundMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
-    <Compile Include="Resolver\ResolveConsoleTestFixture.cs" />
     <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooTextBoxFromSystemWindowsFormsImportedAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTestFixture.cs" />
     <Compile Include="Resolver\ResolveFromImportTestFixture.cs" />
     <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTestFixture.cs" />
+    <Compile Include="Resolver\ResolveConsoleFromSystemImportEverythingFixture.cs" />
     <Compile Include="Resolver\ResolveImportsTestFixture.cs" />
     <Compile Include="Resolver\ResolveLocalClassInstanceTestFixture.cs" />
     <Compile Include="Resolver\ResolveMethodFromUnknownImportAllTestFixture.cs" />
     <Compile Include="Resolver\ResolveMethodWhenFromImportIsUnknownTestFixture.cs" />
     <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTestFixture.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceParseInfoTestFixture.cs" />
+    <Compile Include="Resolver\ResolverContextDottedImportedNameMatchTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModulesThatImportEverythingTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModuleForNameImportedAsDifferentNameTestFixture.cs" />
     <Compile Include="Resolver\ResolverContextGetModuleForImportedNameTests.cs" />
     <Compile Include="Resolver\ResolverContextHasImportTests.cs" />
+    <Compile Include="Resolver\ResolverContextPartialNamespaceExistsTests.cs" />
     <Compile Include="Resolver\ResolverContextUnaliasImportedModuleNameTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTestFixture.cs" />
@@ -399,9 +403,15 @@
     <Compile Include="Resolver\ResolveSystemImportedAsMySystemTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemImportTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTestFixture.cs" />
     <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTestFixture.cs" />
     <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTestFixture.cs" />
     <Compile Include="Resolver\ResolveTestFixtureBase.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportTextBoxTestFixture.cs" />
     <Compile Include="Resolver\ResolveUnknownNamespaceTestFixture.cs" />
     <Compile Include="RunPythonCommandTestFixture.cs" />
     <Compile Include="Utils\AddedComponent.cs" />

src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonIndentationTests.cs

@@ -200,6 +200,18 @@ namespace PythonBinding.Tests.Indentation
 								"\t";
 			
 			Assert.AreEqual(expectedText, textEditor.Text);
-		}		
+		}
+		
+		[Test]
+		public void IndentingFirstLineDoesNotThrowArgumentOutOfRangeException()
+		{
+			textEditor.Text = "print 'hello'";
+			
+			int indentResult = -1;
+			Assert.DoesNotThrow(delegate { indentResult =
+				formattingStrategy.IndentLine(textEditor.ActiveTextAreaControl.TextArea, 0); });
+			
+			Assert.AreEqual("print 'hello'", textEditor.Text);
+		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonLanguagePropertiesTests.cs

@@ -20,5 +20,11 @@ namespace PythonBinding.Tests
 		{
 			Assert.IsNotNull(PythonLanguageProperties.Default.CodeDomProvider);
 		}
+		
+		[Test]
+		public void AllowObjectConstructionOutsideContextReturnsTrueToEnableMethodInsightForConstructors()
+		{
+			Assert.IsTrue(PythonLanguageProperties.Default.AllowObjectConstructionOutsideContext);
+		}
 	}
 }

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

@@ -0,0 +1,60 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveFromSystemImportEverythingFixture : ResolveTestFixtureBase
+	{
+		MockClass consoleClass;
+		
+		protected override ExpressionResult GetExpressionResult()
+		{
+			consoleClass = new MockClass(projectContent, "System.Console");
+			projectContent.ClassToReturnFromGetClass = consoleClass;
+			projectContent.ClassNameForGetClass = "System.Console";
+			
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+			
+			return new ExpressionResult("Console", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System import *\r\n" +
+				"Console\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultResolvedClassIsConsoleClass()
+		{
+			Assert.AreEqual(consoleClass, TypeResolveResult.ResolvedClass);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ProjectContentNamespaceExistsReturnsTrueForSystem()
+		{
+			Assert.IsTrue(projectContent.NamespaceExists("System"));
+		}
+	}
+}

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

@@ -1,84 +0,0 @@
-// <file>
-//     <copyright see="prj:///doc/copyright.txt"/>
-//     <license see="prj:///doc/license.txt"/>
-//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
-//     <version>$Revision$</version>
-// </file>
-
-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>
-	/// Tests the PythonResolver correctly resolves the expression:
-	/// "Console." when the System namespace is imported.
-	/// </summary>
-	[TestFixture]
-	public class ResolveConsoleTestFixture
-	{
-		PythonResolver resolver;
-		MockProjectContent mockProjectContent;
-		ResolveResult resolveResult;
-		MockClass testClass;
-		ICompilationUnit compilationUnit;
-		MockClass systemConsoleClass;
-		
-		[TestFixtureSetUp]
-		public void SetUpFixture()
-		{
-			resolver = new PythonResolver();
-			mockProjectContent = new MockProjectContent();
-			
-			// Do not return any class from GetClass call. This method
-			// will not return anything in the real class since the
-			// type is not fully qualified with its namespace.
-			mockProjectContent.ClassToReturnFromGetClass = null;
-			
-			systemConsoleClass = new MockClass(mockProjectContent, "System.Console");
-			mockProjectContent.ClassesInProjectContent.Add(systemConsoleClass);
-			
-			compilationUnit = new DefaultCompilationUnit(mockProjectContent) { ErrorsDuringCompile = true };
-			testClass = new MockClass(compilationUnit, "Test");
-			compilationUnit.Classes.Add(testClass);
-			ParseInformation parseInfo = new ParseInformation(compilationUnit);
-						
-			string python = "import System\r\n" +
-							"class Test:\r\n" +
-							"\tdef __init__(self):\r\n" +
-							"\tConsole\r\n";
-			ExpressionResult expressionResult = new ExpressionResult("Console", new DomRegion(3, 7), null, null);
-			resolveResult = resolver.Resolve(expressionResult, parseInfo, python);
-		}
-	
-		[Test]
-		public void IsTypeResolveResult()
-		{
-			Assert.IsInstanceOf(typeof(TypeResolveResult), resolveResult);
-		}
-		
-		[Test]
-		public void ResolvedClass()
-		{
-			TypeResolveResult typeResolveResult = resolveResult as TypeResolveResult;
-			Assert.AreEqual(systemConsoleClass, typeResolveResult.ResolvedClass);
-		}
-//		
-//		[Test]
-//		public void IsGetClassCalled()
-//		{
-//			Assert.IsTrue(mockProjectContent.GetClassCalled);
-//		}
-//		
-//		[Test]
-//		public void GetClassName()
-//		{
-//			Assert.AreEqual("System.Console", mockProjectContent.GetClassName);
-//		}		
-	}
-}

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

@@ -0,0 +1,55 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsFooTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
+			
+			return new ExpressionResult("Foo.TextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import System.Windows.Forms as Foo\r\n" +
+				"Foo.TextBox\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveFooWindowsWithImportSystemAsFooTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("Foo.Windows");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System as Foo\r\n" +
+				"Foo.Windows\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemWindowsNamespace()
+		{
+			Assert.AreEqual("System.Windows", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -33,18 +33,19 @@ namespace PythonBinding.Tests.Resolver
 			mockProjectContent = new MockProjectContent();
 			mockProjectContent.AddExistingNamespaceContents("System", new List<ICompletionEntry>());
 			
-			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
-			cu.ErrorsDuringCompile = true;
-			cu.FileName = @"C:\Projects\Test\test.py";
-			ParseInformation parseInfo = new ParseInformation(cu);
-			
 			string python =
 				"import System\r\n" +
 				"class Test:\r\n" +
 				"    def __init__(self):\r\n" +
 				"        System.\r\n";
 			
-			ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(3, 2), null, null);
+			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);
 			resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as NamespaceResolveResult;
 		}
 		

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

@@ -0,0 +1,47 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemNamespaceWithMissingImportTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass systemConsoleClass = new MockClass(projectContent, "System.Console");
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			namespaceItems.Add(systemConsoleClass);
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+
+			return new ExpressionResult("System", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return "System\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNullSinceSystemNamespaceIsNotImported()
+		{
+			Assert.IsNull(resolveResult);
+		}
+		
+		[Test]
+		public void ProjectContentNamespaceExistsReturnsTrueForSystemNamespace()
+		{
+			Assert.IsTrue(projectContent.NamespaceExists("System"));
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemWindowsFormsWithImportSystemTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("System.Windows.Forms");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System\r\n" +
+				"System.Windows.Forms\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemNamespace()
+		{
+			Assert.AreEqual("System.Windows.Forms", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemWindowsWithImportSystemTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("System.Windows");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System\r\n" +
+				"System.Windows\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemWindowsNamespace()
+		{
+			Assert.AreEqual("System.Windows", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,43 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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
+{
+	[TestFixture]
+	public class ResolveSystemWithImportSystemWindowsTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("System");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System.Windows\r\n" +
+				"System\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemNamespace()
+		{
+			Assert.AreEqual("System", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,55 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportTextBoxTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
+			
+			return new ExpressionResult("TextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System.Windows.Forms import TextBox\r\n" +
+				"TextBox\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -0,0 +1,55 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
+			
+			return new ExpressionResult("MyTextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System.Windows.Forms import TextBox as MyTextBox\r\n" +
+				"MyTextBox\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -43,11 +43,5 @@ namespace PythonBinding.Tests.Resolver
 		{
 			Assert.IsNull(resolveResult);
 		}
-		
-		[Test]
-		public void NamespaceExistsCalled()
-		{
-			Assert.IsTrue(projectContent.NamespaceExistsCalled);
-		}	
 	}
 }

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

@@ -0,0 +1,39 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.PythonBinding;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolverContextDottedImportedNameMatchTests
+	{
+		[Test]
+		public void HasDottedImportNameReturnsTrueForSystemWithSystemWindowsFormsImported()
+		{
+			string code = "import System.Windows.Forms";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			Assert.IsTrue(resolverContext.HasDottedImportNameThatStartsWith("System"));
+		}
+		
+		[Test]
+		public void HasDottedImportNameReturnsFalseForMyNamespaceWithMyNamespaceTestImportedWithoutDtso()
+		{
+			string code = "import MyNamespaceTest";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			Assert.IsFalse(resolverContext.HasDottedImportNameThatStartsWith("MyNamespace"));
+		}
+	}
+}

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

@@ -0,0 +1,58 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolverContextPartialNamespaceExistsTests
+	{
+		ParseInformation parseInfo;
+		PythonResolverContext resolverContext;
+		
+		[SetUp]
+		public void Init()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			MockProjectContent winFormsReferenceProjectContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			winFormsReferenceProjectContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(winFormsReferenceProjectContent);
+			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
+			parseInfo = new ParseInformation(unit);
+			
+			resolverContext = new PythonResolverContext(parseInfo);
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsFalseForUnknownNamespace()
+		{
+			string ns = "unknown";
+			Assert.IsFalse(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsTrueForCompleteSystemWinFormsNamespaceMatch()
+		{
+			string ns = "System.Windows.Forms";
+			Assert.IsTrue(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsTrueForSystemWindowsNamespace()
+		{
+			string ns = "System.Windows";
+			Assert.IsTrue(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+	}
+}

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

@@ -32,6 +32,7 @@ namespace PythonBinding.Tests.Utils
 		object project;
 		Dictionary<string, List<ICompletionEntry>> namespaceContents = new Dictionary<string, List<ICompletionEntry>>();
 		LanguageProperties language = LanguageProperties.CSharp;
+		List<IProjectContent> referencedContents = new List<IProjectContent>();
 		
 		public MockProjectContent()
 		{
@@ -143,14 +144,16 @@ namespace PythonBinding.Tests.Utils
 		
 		public ICollection<string> NamespaceNames {
 			get {
-				throw new NotImplementedException();
+				List<string> names = new List<string>();
+				foreach (string existingNamespace in namespaceContents.Keys) {
+					names.Add(existingNamespace);
+				}
+				return names;
 			}
 		}
 		
 		public ICollection<IProjectContent> ReferencedContents {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return this.referencedContents; }
 		}
 		
 		public IUsing DefaultImports {

src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/MockProjectContentTests.cs

@@ -143,5 +143,77 @@ namespace PythonBinding.Tests.Utils.Tests
 			projectContent.NamespaceExists("System");
 			Assert.IsTrue(projectContent.NamespaceExistsCalled);
 		}
+		
+		[Test]
+		public void GetClassReturnsNullByDefault()
+		{
+			Assert.IsNull(projectContent.GetClass("test", 0));
+		}
+		
+		[Test]
+		public void GetClassNameReturnsClassNamePassedToGetClassMethod()
+		{
+			projectContent.GetClass("abc", 0);
+			Assert.AreEqual("abc", projectContent.GetClassName);
+		}
+		
+		[Test]
+		public void GetClassCalledIsFalseByDefault()
+		{
+			Assert.IsFalse(projectContent.GetClassCalled);
+		}
+		
+		[Test]
+		public void GetClassCalledIsTrueAfterGetClassCalled()
+		{
+			projectContent.GetClass("abc", 0);
+			Assert.IsTrue(projectContent.GetClassCalled);
+		}
+		
+		[Test]
+		public void GetClassReturnsClassEvenIfClassNameDoesNotMatchAndNoClassNameForGetClassSpecified()
+		{
+			MockClass c = new MockClass(projectContent, "test");
+			projectContent.ClassToReturnFromGetClass = c;
+			
+			Assert.AreEqual(c, projectContent.GetClass("abcdef", 0));
+		}
+		
+		[Test]
+		public void GetClassReturnsNullIfClassNameDoesNotMatchClassNameForGetClassProperty()
+		{
+			MockClass c = new MockClass(projectContent, "test");
+			projectContent.ClassToReturnFromGetClass = c;
+			projectContent.ClassNameForGetClass = "test";
+			
+			Assert.IsNull(projectContent.GetClass("abcdef", 0));
+		}
+		
+		[Test]
+		public void GetClassReturnsClassIfClassNameMatchesClassNameForGetClassProperty()
+		{
+			MockClass c = new MockClass(projectContent, "test");
+			projectContent.ClassToReturnFromGetClass = c;
+			projectContent.ClassNameForGetClass = "test";
+			
+			Assert.AreEqual(c, projectContent.GetClass("test", 0));
+		}
+		
+		[Test]
+		public void NamespaceNamesHasNoItemsByDefault()
+		{
+			Assert.AreEqual(0, projectContent.ReferencedContents.Count);
+		}
+		
+		[Test]
+		public void NamespaceNamesContainingsNamespaceAddedToExistingNamespaces()
+		{
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+			List<string> expectedNames = new List<string>();
+			expectedNames.Add("System");
+			
+			Assert.AreEqual(expectedNames, projectContent.NamespaceNames);
+		}
 	}
 }

src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.xml

@@ -328,7 +328,7 @@
             <summary>
             Convert an object to a 32-bit integer. This adds two features to Converter.ToInt32:
               1. Sign is ignored. For example, 0xffff0000 converts to 4294901760, where Convert.ToInt32
-                 would throw because 0xffff000 is less than zero.
+                 would throw because 0xffff0000 is less than zero.
               2. Overflow exceptions are thrown. Converter.ToInt32 throws TypeError if x is
                  an integer, but is bigger than 32 bits. Instead, we throw OverflowException.
             </summary>
@@ -735,6 +735,9 @@
         <member name="F:IronPython.Modules.CTypes.SimpleTypeKind.Boolean">
             <summary> '?' </summary>
         </member>
+        <member name="F:IronPython.Modules.CTypes.SimpleTypeKind.VariantBool">
+            <summary> 'v' </summary>
+        </member>
         <member name="T:IronPython.Modules.CTypes.CData">
             <summary>
             Base class for all ctypes interop types.
@@ -804,6 +807,12 @@
             Gets the required alignment for the type
             </summary>
         </member>
+        <member name="P:IronPython.Modules.CTypes.INativeType.TypeFormat">
+            <summary>
+            Returns a string which describes the type.  Used for _buffer_info implementation which
+            only exists for testing purposes.
+            </summary>
+        </member>
         <member name="M:IronPython.Modules.CTypes.ArrayType.from_param(System.Object)">
             <summary>
             Converts an object into a function call parameter.
@@ -1099,7 +1108,12 @@
             Gets or sets the dictionary used for storing extra attributes on the partial object.
             </summary>
         </member>
-        <member name="M:IronPython.Modules.PythonWeakRef.ref.RefEquals(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+        <member name="M:IronPython.Modules.PythonWeakRef.ref.__hash__(IronPython.Runtime.CodeContext)">
+            <summary>
+            Special hash function because IStructuralEquatable.GetHashCode is not allowed to throw.
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.PythonWeakRef.ref.RefEquals(System.Object,System.Object,System.Collections.IEqualityComparer)">
             <summary>
             Special equals because none of the special cases in Ops.Equals
             are applicable here, and the reference equality check breaks some tests.
@@ -1110,10 +1124,20 @@
             gets the object or throws a reference exception
             </summary>
         </member>
+        <member name="M:IronPython.Modules.PythonWeakRef.weakproxy.__eq__(System.Object)">
+            <summary>
+            Special equality function because IStructuralEquatable.Equals is not allowed to throw.
+            </summary>
+        </member>
         <member name="M:IronPython.Modules.PythonWeakRef.weakcallableproxy.GetObject">
             <summary>
             gets the object or throws a reference exception
             </summary>
         </member>
+        <member name="M:IronPython.Modules.PythonWeakRef.weakcallableproxy.__eq__(System.Object)">
+            <summary>
+            Special equality function because IStructuralEquatable.Equals is not allowed to throw.
+            </summary>
+        </member>
     </members>
 </doc>