Added method completion for standard python modules that import all members (from sys import*).

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@5434 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

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

@@ -74,13 +74,18 @@
     <Compile Include="Src\AddInOptions.cs" />
     <Compile Include="Src\CompilingOptionsPanel.cs" />
     <Compile Include="Src\MemberName.cs" />
+    <Compile Include="Src\PythonBuiltInModuleMemberName.cs" />
     <Compile Include="Src\PythonClassResolver.cs" />
+    <Compile Include="Src\PythonDotNetMethodResolver.cs" />
     <Compile Include="Src\PythonImport.cs" />
+    <Compile Include="Src\PythonMethodGroupResolveResult.cs" />
     <Compile Include="Src\PythonMethodResolver.cs" />
     <Compile Include="Src\PythonModuleCompletionItems.cs" />
     <Compile Include="Src\PythonModuleCompletionItemsFactory.cs" />
     <Compile Include="Src\PythonNamespaceResolver.cs" />
     <Compile Include="Src\PythonResolverContext.cs" />
+    <Compile Include="Src\PythonStandardModuleMethodResolver.cs" />
+    <Compile Include="Src\PythonStandardModuleMethodResolveResult.cs" />
     <Compile Include="Src\PythonStandardModuleResolver.cs" />
     <Compile Include="Src\PythonStandardModuleResolveResult.cs" />
     <Compile Include="Src\PythonStandardModuleType.cs" />

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

@@ -0,0 +1,26 @@
+// <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;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonBuiltInModuleMemberName : MemberName
+	{
+		public const string PythonBuiltInModuleName = "__builtin__";
+		
+		public PythonBuiltInModuleMemberName(string memberName)
+			: base(PythonBuiltInModuleName, memberName)
+		{
+		}
+		
+		public static bool IsBuiltInModule(string name)
+		{
+			return name == PythonBuiltInModuleName;
+		}
+	}
+}

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

@@ -0,0 +1,32 @@
+// <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;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonDotNetMethodResolver
+	{
+		PythonClassResolver classResolver;
+		
+		public PythonDotNetMethodResolver(PythonClassResolver classResolver)
+		{
+			this.classResolver = classResolver;
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			MemberName memberName = new MemberName(expressionResult.Expression);
+			IClass matchingClass = classResolver.GetClass(resolverContext, memberName.Type);
+			if (matchingClass != null) {
+				return new PythonMethodGroupResolveResult(matchingClass, memberName.Name);
+			}
+			return null;
+		}
+	}
+}

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

@@ -21,15 +21,15 @@ namespace ICSharpCode.PythonBinding
 			this.fromImport = fromImport;
 		}
 		
-		public bool HasIdentifier(string name)
+		public bool IsImportedName(string name)
 		{
 			if (String.IsNullOrEmpty(name)) {
 				return false;
 			}
 			
 			for (int i = 0; i < fromImport.Names.Count; ++i) {
-				string identifier = GetImportedAsNameIfExists(i);
-				if (identifier == name) {
+				string importedName = GetImportedAsNameIfExists(i);
+				if (importedName == name) {
 					return true;
 				}
 			}
@@ -38,9 +38,11 @@ namespace ICSharpCode.PythonBinding
 		
 		string GetImportedAsNameIfExists(int index)
 		{
-			string identifier = fromImport.AsNames[index];
-			if (identifier != null) {
-				return identifier;
+			if (fromImport.AsNames != null) {
+				string importedAsName = fromImport.AsNames[index];
+				if (importedAsName != null) {
+					return importedAsName;
+				}
 			}
 			return fromImport.Names[index];
 		}
@@ -49,13 +51,23 @@ namespace ICSharpCode.PythonBinding
 			get { return fromImport.Root.MakeString(); }
 		}
 		
-		public string GetIdentifierForAlias(string alias)
+		public string GetOriginalNameForAlias(string alias)
 		{
+			if (fromImport.AsNames == null) {
+				return null;
+			}
+			
 			int index = fromImport.AsNames.IndexOf(alias);
 			if (index >= 0) {
 				return fromImport.Names[index];
 			}
 			return null;
 		}
+		
+		public bool ImportsEverything {
+			get {
+				return fromImport.Names[0] == "*";
+			}
+		}
 	}
 }

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

@@ -0,0 +1,20 @@
+// <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;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonMethodGroupResolveResult : MethodGroupResolveResult
+	{
+		public PythonMethodGroupResolveResult(IClass containingClass, string methodName)
+			: base(null, null, containingClass.DefaultReturnType, methodName)
+		{
+		}
+	}
+}

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

@@ -12,98 +12,22 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonMethodResolver
 	{
-		PythonClassResolver classResolver;
-		PythonStandardModuleResolver standardModuleResolver;
+		PythonDotNetMethodResolver dotNetMethodResolver;
+		PythonStandardModuleMethodResolver standardModuleMethodResolver;
 		
 		public PythonMethodResolver(PythonClassResolver classResolver, PythonStandardModuleResolver standardModuleResolver)
 		{
-			this.classResolver = classResolver;
-			this.standardModuleResolver = standardModuleResolver;
+			dotNetMethodResolver = new PythonDotNetMethodResolver(classResolver);
+			standardModuleMethodResolver = new PythonStandardModuleMethodResolver(standardModuleResolver);
 		}
 		
 		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
 		{
-			MemberName memberName = new MemberName(expressionResult.Expression);
-			MethodGroupResolveResult resolveResult = GetDotNetMethodResolveResult(resolverContext, memberName);
+			ResolveResult resolveResult = dotNetMethodResolver.Resolve(resolverContext, expressionResult);
 			if (resolveResult != null) {
 				return resolveResult;
 			}
-			return GetStandardModuleMethodResolveResult(resolverContext, memberName);
-		}
-		
-		MethodGroupResolveResult GetDotNetMethodResolveResult(PythonResolverContext resolverContext, MemberName memberName)
-		{
-			IClass matchingClass = classResolver.GetClass(resolverContext, memberName.Type);
-			if (matchingClass != null) {
-				return CreateMethodGroupResolveResult(matchingClass, memberName.Name);
-			}
-			return null;
-		}
-		
-		MethodGroupResolveResult GetStandardModuleMethodResolveResult(PythonResolverContext resolverContext, MemberName memberName)
-		{
-			MethodGroupResolveResult result = GetStandardModuleMethodResolveResultFromImportedIdentifiers(resolverContext, memberName);
-			if (result != null) {
-				return result;
-			}
-			return GetStandardModuleMethodResolveResultIfFromImports(resolverContext, memberName);
-		}
-		
-		MethodGroupResolveResult GetStandardModuleMethodResolveResultFromImportedIdentifiers(PythonResolverContext resolverContext, MemberName memberName)
-		{
-			if (!memberName.HasName) {
-				string identifier = memberName.Type;
-				string moduleName = resolverContext.GetModuleForIdentifier(identifier);
-				if (moduleName != null) {
-					PythonStandardModuleType type = standardModuleResolver.GetStandardModuleType(moduleName);
-					if (type != null) {
-						identifier = resolverContext.UnaliasIdentifier(identifier);
-						return GetStandardModuleMethodResolveResult(type, identifier);
-					}
-				}
-			}
-			return null;
-		}
-		
-		MethodGroupResolveResult GetStandardModuleMethodResolveResultIfFromImports(PythonResolverContext resolverContext, MemberName memberName)
-		{
-			if (!memberName.HasName) {
-				memberName = CreateBuiltinModuleMemberName(memberName.Type);
-			}
-			
-			PythonStandardModuleType type = standardModuleResolver.GetStandardModuleTypeIfImported(resolverContext, memberName.Type);
-			if (type != null) {
-				return GetStandardModuleMethodResolveResult(type, memberName.Name);
-			}
-			return null;
-		}
-		
-		MemberName CreateBuiltinModuleMemberName(string memberName)
-		{
-			return new MemberName(PythonStandardModuleResolver.PythonBuiltInModuleName, memberName);
-		}
-		
-		MethodGroupResolveResult GetStandardModuleMethodResolveResult(PythonStandardModuleType type, string methodName)
-		{
-			PythonModuleCompletionItems completionItems = PythonModuleCompletionItemsFactory.Create(type);
-			MethodGroup methods = completionItems.GetMethods(methodName);
-			if (methods.Count > 0) {
-				return CreateMethodGroupResolveResult(methods);
-			}
-			return null;
-		}
-		
-		MethodGroupResolveResult CreateMethodGroupResolveResult(IClass c, string methodName)
-		{
-			return new MethodGroupResolveResult(null, null, c.DefaultReturnType, methodName);
-		}
-		
-		MethodGroupResolveResult CreateMethodGroupResolveResult(MethodGroup methods)
-		{
-			MethodGroup[] methodGroups = new MethodGroup[] { methods };
-			IMethod method = methods[0];
-			IReturnType returnType = new DefaultReturnType(method.DeclaringType);
-			return new MethodGroupResolveResult(null, null, returnType, method.Name, methodGroups);
+			return standardModuleMethodResolver.Resolve(resolverContext, expressionResult);
 		}
 	}
 }

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

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.PythonBinding
@@ -177,12 +178,12 @@ namespace ICSharpCode.PythonBinding
 		/// <summary>
 		/// Looks for the module name where the specified identifier is imported from.
 		/// </summary>
-		public string GetModuleForIdentifier(string identifier)
+		public string GetModuleForImportedName(string name)
 		{
 			foreach (IUsing u in mostRecentCompilationUnit.UsingScope.Usings) {
 				PythonImport pythonImport = u as PythonImport;
 				if (pythonImport != null) {
-					if (pythonImport.HasIdentifier(identifier)) {
+					if (pythonImport.IsImportedName(name)) {
 						return pythonImport.Module;
 					}
 				}
@@ -193,18 +194,32 @@ namespace ICSharpCode.PythonBinding
 		/// <summary>
 		/// Converts a name into the correct identifier name based on any from import as statements.
 		/// </summary>
-		public string UnaliasIdentifier(string name)
+		public string UnaliasImportedName(string name)
 		{
 			foreach (IUsing u in mostRecentCompilationUnit.UsingScope.Usings) {
 				PythonImport pythonImport = u as PythonImport;
 				if (pythonImport != null) {
-					string actualIdentifierName = pythonImport.GetIdentifierForAlias(name);
-					if (actualIdentifierName != null) {
-						return actualIdentifierName;
+					string actualName = pythonImport.GetOriginalNameForAlias(name);
+					if (actualName != null) {
+						return actualName;
 					}
 				}
 			}
 			return name;
 		}
+		
+		public string[] GetModulesThatImportEverything()
+		{
+			List<string> modules = new List<string>();
+			foreach (IUsing u in mostRecentCompilationUnit.UsingScope.Usings) {
+				PythonImport pythonImport = u as PythonImport;
+				if (pythonImport != null) {
+					if (pythonImport.ImportsEverything) {
+						modules.Add(pythonImport.Module);
+					}
+				}
+			}
+			return modules.ToArray();
+		}
 	}
 }

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

@@ -0,0 +1,38 @@
+// <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;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonStandardModuleMethodGroupResolveResult : MethodGroupResolveResult
+	{
+		public PythonStandardModuleMethodGroupResolveResult(IReturnType containingType, string methodName, MethodGroup[] methodGroups)
+			: base(null, null, containingType, methodName, methodGroups)
+		{
+		}
+		
+		public static PythonStandardModuleMethodGroupResolveResult Create(PythonStandardModuleType type, string methodName)
+		{
+			PythonModuleCompletionItems completionItems = PythonModuleCompletionItemsFactory.Create(type);
+			MethodGroup methods = completionItems.GetMethods(methodName);
+			if (methods.Count > 0) {
+				return Create(methods);
+			}
+			return null;
+		}
+		
+		static PythonStandardModuleMethodGroupResolveResult Create(MethodGroup methods)
+		{
+			MethodGroup[] methodGroups = new MethodGroup[] { methods };
+			IMethod method = methods[0];
+			IReturnType returnType = new DefaultReturnType(method.DeclaringType);
+			return new PythonStandardModuleMethodGroupResolveResult(returnType, method.Name, methodGroups);
+		}
+	}
+}

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

@@ -0,0 +1,84 @@
+// <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;
+
+namespace ICSharpCode.PythonBinding
+{
+	public class PythonStandardModuleMethodResolver
+	{
+		PythonStandardModuleResolver standardModuleResolver;
+		
+		public PythonStandardModuleMethodResolver(PythonStandardModuleResolver standardModuleResolver)
+		{
+			this.standardModuleResolver = standardModuleResolver;
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			MemberName memberName = new MemberName(expressionResult.Expression);
+			MethodGroupResolveResult result = ResolveMethodFromImportedNames(resolverContext, memberName);
+			if (result != null) {
+				return result;
+			}
+			result = ResolveIfMethodIsImported(resolverContext, memberName);
+			if (result != null) {
+				return result;
+			}
+			return ResolveMethodFromModulesThatImportEverything(resolverContext, memberName);
+		}
+		
+		MethodGroupResolveResult ResolveMethodFromImportedNames(PythonResolverContext resolverContext, MemberName memberName)
+		{
+			if (!memberName.HasName) {
+				string name = memberName.Type;
+				string moduleName = resolverContext.GetModuleForImportedName(name);
+				if (moduleName != null) {
+					PythonStandardModuleType type = standardModuleResolver.GetStandardModuleType(moduleName);
+					if (type != null) {
+						name = resolverContext.UnaliasImportedName(name);
+						return PythonStandardModuleMethodGroupResolveResult.Create(type, name);
+					}
+				}
+			}
+			return null;
+		}
+		
+		MethodGroupResolveResult ResolveIfMethodIsImported(PythonResolverContext resolverContext, MemberName memberName)
+		{
+			if (!memberName.HasName) {
+				memberName = new PythonBuiltInModuleMemberName(memberName.Type);
+			}
+			
+			PythonStandardModuleType type = standardModuleResolver.GetStandardModuleTypeIfImported(resolverContext, memberName.Type);
+			if (type != null) {
+				return CreateResolveResult(type, memberName.Name);
+			}
+			return null;
+		}
+		
+		MethodGroupResolveResult ResolveMethodFromModulesThatImportEverything(PythonResolverContext resolverContext, MemberName memberName)
+		{
+			foreach (string module in resolverContext.GetModulesThatImportEverything()) {
+				PythonStandardModuleType type = standardModuleResolver.GetStandardModuleType(module);
+				if (type != null) {
+					MethodGroupResolveResult resolveResult = CreateResolveResult(type, memberName.Type);
+					if (resolveResult != null) {
+						return resolveResult;
+					}
+				}
+			}
+			return null;
+		}
+		
+		MethodGroupResolveResult CreateResolveResult(PythonStandardModuleType type, string name)
+		{
+			return PythonStandardModuleMethodGroupResolveResult.Create(type, name);
+		}
+	}
+}

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

@@ -12,7 +12,6 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonStandardModuleResolver
 	{
-		public const string PythonBuiltInModuleName = "__builtin__";
 		PythonStandardModules standardPythonModules = new PythonStandardModules();
 		
 		public PythonStandardModuleResolver()
@@ -30,7 +29,7 @@ namespace ICSharpCode.PythonBinding
 		
 		public PythonStandardModuleType GetStandardModuleTypeIfImported(PythonResolverContext resolverContext, string moduleName)
 		{
-			if (resolverContext.HasImport(moduleName) || IsBuiltInModule(moduleName)) {
+			if (resolverContext.HasImport(moduleName) || PythonBuiltInModuleMemberName.IsBuiltInModule(moduleName)) {
 				return standardPythonModules.GetModuleType(moduleName);
 			}
 			return null;
@@ -40,10 +39,5 @@ namespace ICSharpCode.PythonBinding
 		{
 			return standardPythonModules.GetModuleType(moduleName);
 		}
-		
-		bool IsBuiltInModule(string name)
-		{
-			return name == PythonBuiltInModuleName;
-		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromMathImportAllTestFixture.cs

@@ -0,0 +1,52 @@
+// <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.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+
+namespace PythonBinding.Tests.Parsing
+{
+	[TestFixture]
+	public class ParseFromMathImportAllTestFixture
+	{
+		ICompilationUnit compilationUnit;
+		PythonImport import;
+		
+		[SetUp]
+		public void Init()
+		{
+			string python = "from math import *";
+			
+			DefaultProjectContent projectContent = new DefaultProjectContent();
+			PythonParser parser = new PythonParser();
+			compilationUnit = parser.Parse(projectContent, @"C:\test.py", python);
+			import = compilationUnit.UsingScope.Usings[0] as PythonImport;
+		}
+		
+		[Test]
+		public void PythonImportContainsMathModuleName()
+		{
+			Assert.AreEqual("math", import.Module);
+		}
+		
+		[Test]
+		public void PythonImportImportsEverythingReturnsTrue()
+		{
+			Assert.IsTrue(import.ImportsEverything);
+		}
+		
+		[Test]
+		public void PythonImportGetIdentifierForAliasDoesNotThrowNullReferenceException()
+		{
+			string identifier = String.Empty;
+			Assert.DoesNotThrow(delegate { identifier = import.GetOriginalNameForAlias("unknown"); });
+			Assert.IsNull(identifier);
+		}
+	}
+}

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromMathImportCosAndTanTestFixture.cs

@@ -13,7 +13,7 @@ using NUnit.Framework;
 namespace PythonBinding.Tests.Parsing
 {
 	[TestFixture]
-	public class ParseFromMathImportCosAndTanExitTestFixture
+	public class ParseFromMathImportCosAndTanTestFixture
 	{
 		ICompilationUnit compilationUnit;
 		PythonImport import;
@@ -32,7 +32,7 @@ namespace PythonBinding.Tests.Parsing
 		[Test]
 		public void UsingAsPythonImportHasCosIdentifier()
 		{
-			Assert.IsTrue(import.HasIdentifier("cos"));
+			Assert.IsTrue(import.IsImportedName("cos"));
 		}
 		
 		[Test]
@@ -40,17 +40,23 @@ namespace PythonBinding.Tests.Parsing
 		{
 			Assert.AreEqual("math", import.Module);
 		}
-
+		
 		[Test]
 		public void UsingAsPythonImportHasTanIdentifier()
 		{
-			Assert.IsTrue(import.HasIdentifier("tan"));
+			Assert.IsTrue(import.IsImportedName("tan"));
 		}
-
+		
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveACosIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier("acos"));
+			Assert.IsFalse(import.IsImportedName("acos"));
+		}
+		
+		[Test]
+		public void PythonImportImportsEverythingReturnsFalse()
+		{
+			Assert.IsFalse(import.ImportsEverything);
 		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromSysImportExitAsMyExitTestFixture.cs

@@ -32,19 +32,19 @@ namespace PythonBinding.Tests.Parsing
 		[Test]
 		public void UsingAsPythonImportHasMyExitIdentifier()
 		{
-			Assert.IsTrue(import.HasIdentifier("myexit"));
+			Assert.IsTrue(import.IsImportedName("myexit"));
 		}
 		
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveExitIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier("exit"));
+			Assert.IsFalse(import.IsImportedName("exit"));
 		}
 		
 		[Test]
 		public void PythonImportGetIdentifierFromAliasReturnsExitForMyExit()
 		{
-			Assert.AreEqual("exit", import.GetIdentifierForAlias("myexit"));
+			Assert.AreEqual("exit", import.GetOriginalNameForAlias("myexit"));
 		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromSysImportExitTestFixture.cs

@@ -32,13 +32,13 @@ namespace PythonBinding.Tests.Parsing
 		[Test]
 		public void UsingAsPythonImportHasExitIdentifier()
 		{
-			Assert.IsTrue(import.HasIdentifier("exit"));
+			Assert.IsTrue(import.IsImportedName("exit"));
 		}
 		
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveUnknownIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier("unknown"));
+			Assert.IsFalse(import.IsImportedName("unknown"));
 		}
 		
 		[Test]

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromSysImportMissingImportTestFixture.cs

@@ -32,13 +32,13 @@ namespace PythonBinding.Tests.Parsing
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveEmptyStringIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier(String.Empty));
+			Assert.IsFalse(import.IsImportedName(String.Empty));
 		}
 		
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveNullIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier(null));
+			Assert.IsFalse(import.IsImportedName(null));
 		}
 		
 		[Test]

src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/ParseFromSysImportWithoutImportedNameTestFixture.cs

@@ -13,7 +13,7 @@ using NUnit.Framework;
 namespace PythonBinding.Tests.Parsing
 {
 	[TestFixture]
-	public class ParseFromSysImportWithoutIdentifierTestFixture
+	public class ParseFromSysImportWithoutImportedNameTestFixture
 	{
 		ICompilationUnit compilationUnit;
 		PythonImport import;
@@ -32,13 +32,13 @@ namespace PythonBinding.Tests.Parsing
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveEmptyStringIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier(String.Empty));
+			Assert.IsFalse(import.IsImportedName(String.Empty));
 		}
 		
 		[Test]
 		public void UsingAsPythonImportDoesNotHaveNullIdentifier()
 		{
-			Assert.IsFalse(import.HasIdentifier(null));
+			Assert.IsFalse(import.IsImportedName(null));
 		}
 		
 		[Test]

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

@@ -335,11 +335,12 @@
     <Compile Include="Parsing\MissingLastParameterFromMethodTestFixture.cs" />
     <Compile Include="Parsing\ParseClassWithCtorTestFixture.cs" />
     <Compile Include="Parsing\ParseClassWithMethodTestFixture.cs" />
-    <Compile Include="Parsing\ParseFromMathImportCosAndTanExitTestFixture.cs" />
+    <Compile Include="Parsing\ParseFromMathImportAllTestFixture.cs" />
+    <Compile Include="Parsing\ParseFromMathImportCosAndTanTestFixture.cs" />
     <Compile Include="Parsing\ParseFromSysImportExitAsMyExitTestFixture.cs" />
     <Compile Include="Parsing\ParseFromSysImportExitTestFixture.cs" />
     <Compile Include="Parsing\ParseFromSysImportMissingImportTestFixture.cs" />
-    <Compile Include="Parsing\ParseFromSysImportWithoutIdentifierTestFixture.cs" />
+    <Compile Include="Parsing\ParseFromSysImportWithoutImportedNameTestFixture.cs" />
     <Compile Include="Parsing\ParseImportMultipleModulesTestFixture.cs" />
     <Compile Include="Parsing\ParseImportTestFixture.cs" />
     <Compile Include="Parsing\ParseInvalidPythonCodeTestFixture.cs" />
@@ -366,10 +367,14 @@
     <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTestFixture.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\ResolveNullCtrlSpaceCompilationUnitTestFixture.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceParseInfoTestFixture.cs" />
-    <Compile Include="Resolver\ResolverContextGetModuleForIdentifierImportedAsDifferentNameTestFixture.cs" />
-    <Compile Include="Resolver\ResolverContextGetModuleForIdentifierTests.cs" />
+    <Compile Include="Resolver\ResolverContextGetModulesThatImportEverythingTests.cs" />
+    <Compile Include="Resolver\ResolverContextGetModuleForNameImportedAsDifferentNameTestFixture.cs" />
+    <Compile Include="Resolver\ResolverContextGetModuleForImportedNameTests.cs" />
     <Compile Include="Resolver\ResolverContextHasImportTests.cs" />
     <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleTestFixture.cs">
@@ -379,6 +384,7 @@
     <Compile Include="Resolver\ResolveSystemConsoleTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemImportTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTestFixture.cs" />
     <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTestFixture.cs" />
     <Compile Include="Resolver\ResolveTestFixtureBase.cs" />
     <Compile Include="Resolver\ResolveUnknownNamespaceTestFixture.cs" />

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

@@ -0,0 +1,41 @@
+// <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 ResolveMethodFromUnknownImportAllTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import *\r\n" +
+				"methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,40 @@
+// <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 NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveMethodWhenFromImportIsUnknownTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import methodcall\r\n" +
+				"methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,40 @@
+// <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 NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveMethodWhenImportIsUnknownTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("unknown.methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import methodcall\r\n" +
+				"unknown.methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,67 @@
+// <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 ResolveTanMethodFromMathImportAllTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("tan", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"from sys import *\r\n" +
+				"from math import *\r\n" +
+				"from socket import *\r\n" +
+				"\r\n" +
+				"tan\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsTan()
+		{
+			Assert.AreEqual("tan", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ResolveResultContainingTypeHasOneTanMethods()
+		{
+			List<IMethod> tanMethods = GetTanMethods();
+			Assert.AreEqual(1, tanMethods.Count);
+		}
+		
+		List<IMethod> GetTanMethods()
+		{
+			List<IMethod> methods = MethodResolveResult.ContainingType.GetMethods();
+			return PythonCompletionItemsHelper.FindAllMethodsFromCollection("tan", -1, methods.ToArray());
+		}
+	}
+}

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

@@ -14,7 +14,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolverContextGetModuleForIdentifierTestFixture
+	public class ResolverContextGetModuleForImportedNameTestFixture
 	{
 		PythonResolverContext resolverContext;
 		ParseInformation parseInfo;
@@ -31,21 +31,21 @@ namespace PythonBinding.Tests.Resolver
 		}
 		
 		[Test]
-		public void ResolverContextGetModuleForIdentifierReturnsSysForExitIdentifier()
+		public void ResolverContextGetModuleForImportedNameReturnsSysForExitImportedName()
 		{
-			Assert.AreEqual("sys", resolverContext.GetModuleForIdentifier("exit"));
+			Assert.AreEqual("sys", resolverContext.GetModuleForImportedName("exit"));
 		}
 		
 		[Test]
-		public void ResolverContextGetModuleForIdentifierReturnsNullForUnknownIdentifier()
+		public void ResolverContextGetModuleForImportedNameReturnsNullForUnknownImportedName()
 		{
-			Assert.IsNull(resolverContext.GetModuleForIdentifier("unknown"));
+			Assert.IsNull(resolverContext.GetModuleForImportedName("unknown"));
 		}
 		
 		[Test]
-		public void ResolverContextGetImportedIdentifierNameReturnsExitForExitIdentifier()
+		public void ResolverContextGetImportedImportedNameNameReturnsExitForExitImportedName()
 		{
-			Assert.AreEqual("exit", resolverContext.UnaliasIdentifier("exit"));
+			Assert.AreEqual("exit", resolverContext.UnaliasImportedName("exit"));
 		}
 	}
 }

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

@@ -14,7 +14,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolverContextGetModuleForIdentifierImportedAsDifferentNameTestFixture
+	public class ResolverContextGetModuleForNameImportedAsDifferentNameTestFixture
 	{
 		PythonResolverContext resolverContext;
 		ParseInformation parseInfo;
@@ -30,27 +30,27 @@ namespace PythonBinding.Tests.Resolver
 		}
 		
 		[Test]
-		public void ResolverContextGetModuleForIdentifierReturnsSysForMyExitIdentifier()
+		public void ResolverContextGetModuleForNameReturnsSysForMyExitName()
 		{
-			Assert.AreEqual("sys", resolverContext.GetModuleForIdentifier("myexit"));
+			Assert.AreEqual("sys", resolverContext.GetModuleForImportedName("myexit"));
 		}
 		
 		[Test]
-		public void ResolverContextGetModuleForIdentifierReturnsNullForExitIdentifier()
+		public void ResolverContextGetModuleForImportedNameReturnsNullForExitImportedName()
 		{
-			Assert.IsNull(resolverContext.GetModuleForIdentifier("exit"));
+			Assert.IsNull(resolverContext.GetModuleForImportedName("exit"));
 		}
 		
 		[Test]
-		public void ResolverContextUnaliasIdentiferReturnsMyExitForExitIdentifier()
+		public void ResolverContextUnaliasIdentiferReturnsMyExitForExitImportedName()
 		{
-			Assert.AreEqual("exit", resolverContext.UnaliasIdentifier("myexit"));
+			Assert.AreEqual("exit", resolverContext.UnaliasImportedName("myexit"));
 		}
 		
 		[Test]
-		public void ResolverContextUnaliasIdentifierReturnsOriginalNameWhenNoAliasIsFound()
+		public void ResolverContextUnaliasImportedNameReturnsOriginalNameWhenNoAliasIsFound()
 		{
-			Assert.AreEqual("unknown", resolverContext.UnaliasIdentifier("unknown"));
+			Assert.AreEqual("unknown", resolverContext.UnaliasImportedName("unknown"));
 		}
 	}
 }

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

@@ -0,0 +1,73 @@
+// <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 ResolverContextGetImportAllModulesTests
+	{
+		[Test]
+		public void GetModulesThatImportEverythingReturnsEmptyCollectionIfNotImportAll()
+		{
+			string code = "from math import tan";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			
+			string[] expectedModules = new string[0];
+			Assert.AreEqual(expectedModules, resolverContext.GetModulesThatImportEverything());
+		}
+		
+		[Test]
+		public void GetModulesThatImportEverythingReturnsSysForFromSysImportAllStatement()
+		{
+			string code = "from sys import *";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			
+			string[] expectedModules = new string[] { "sys" };
+			Assert.AreEqual(expectedModules, resolverContext.GetModulesThatImportEverything());
+		}
+		
+		[Test]
+		public void GetModulesThatImportEverythingReturnsSysAndMathForFromSysImportAllStatement()
+		{
+			string code =
+				"from sys import *\r\n" +
+				"from math import *";
+			
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			
+			string[] expectedModules = new string[] { "sys", "math" };
+			Assert.AreEqual(expectedModules, resolverContext.GetModulesThatImportEverything());
+		}
+		
+		[Test]
+		public void GetModulesThatImportEverythingIgnoresNonFromImportStatement()
+		{
+			string code = 
+				"import math\r\n" +
+				"from sys import *";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			
+			string[] expectedModules = new string[] { "sys" };
+			Assert.AreEqual(expectedModules, resolverContext.GetModulesThatImportEverything());
+		}
+
+	}
+}