Fixed code completion bugs: incorrect return type for System.Collections.Generic.Comparer<T>.Default (forum-7270), tooltip not shown for protected method calls when there is a class with the same name as the called method.

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

data/templates/file/CSharp/CSharp.RecentFilesCollection.xft

@@ -4,6 +4,7 @@
 		name		= "${res:Templates.File.RecentFilesCollection.Name}"
 		icon		= "C#.File.NewClass"
 		category	= "C#"
+		subcategory	= "Configuration Classes"
 		defaultname	= "Class${Number}.cs"
 		language	= "C#"/>
 	<Description>${res:Templates.File.RecentFilesCollection.Description}</Description>  

src/AddIns/Misc/UnitTesting/Src/RunTestCommands.cs

@@ -79,7 +79,6 @@ namespace ICSharpCode.UnitTesting
 					}
 				} catch {
 					runningTestCommand = null;
-					ProjectService.RaiseEventEndBuild();
 					throw;
 				}
 			}
@@ -151,7 +150,6 @@ namespace ICSharpCode.UnitTesting
 					ShowErrorList();
 				}
 				OnAfterRunTests();
-				ProjectService.RaiseEventEndBuild();
 			}
 		}
 		
@@ -227,7 +225,6 @@ namespace ICSharpCode.UnitTesting
 			ResetAllTestResults();
 			
 			OnBeforeRunTests();
-			ProjectService.RaiseEventEndBuild();
 		}
 				
 		/// <summary>
@@ -332,7 +329,6 @@ namespace ICSharpCode.UnitTesting
 				if (TaskService.SomethingWentWrong && ErrorListPad.ShowAfterBuild) {
 					ShowErrorList();
 				}
-				ProjectService.RaiseEventEndBuild();
 			}
 		}
 		
@@ -415,6 +411,7 @@ namespace ICSharpCode.UnitTesting
 		/// </summary>
 		public override void BeforeBuild()
 		{
+			ProjectService.RaiseEventStartBuild();
 			SaveAllFiles.SaveAll();
 		}
 		
@@ -423,6 +420,7 @@ namespace ICSharpCode.UnitTesting
 		/// </summary>
 		public override void AfterBuild()
 		{
+			ProjectService.RaiseEventEndBuild();
 		}
 	}
 		

src/Main/Base/Project/Src/Project/MSBuildBasedProject.cs

@@ -147,6 +147,7 @@ namespace ICSharpCode.SharpDevelop.Project
 			Name = information.ProjectName;
 			FileName = information.OutputProjectFileName;
 			
+			project.FullFileName = information.OutputProjectFileName;
 			project.DefaultToolsVersion = "3.5";
 			
 			base.IdGuid = "{" + Guid.NewGuid().ToString().ToUpperInvariant() + "}";

src/Main/Base/Test/GenericResolverTests.cs

@@ -193,6 +193,23 @@ class DerivedClass<A,B> : BaseClass<B,A> {
 			rr = Resolve(program, "b", 7) as MemberResolveResult;
 			Assert.AreEqual("A", rr.ResolvedType.Name);
 		}
+		
+		[Test]
+		public void PropertyOnGenericClass()
+		{
+			string program = @"using System;
+class T {
+	void M() {
+	
+	}
+}
+";
+			MemberResolveResult rr = Resolve(program, "System.Collections.Generic.Comparer<string>.Default", 4) as MemberResolveResult;
+			Assert.AreEqual("System.Collections.Generic.Comparer.Default", rr.ResolvedMember.FullyQualifiedName);
+			Assert.AreEqual("System.Collections.Generic.Comparer<string>",
+			                (new Dom.CSharp.CSharpAmbience { ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames } )
+			                .Convert(rr.ResolvedType));
+		}
 		#endregion
 		
 		#region CodeCompletion inside generic classes

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -1165,6 +1165,25 @@ class B {
 			Assert.IsTrue(result != null && result.IsValid, "member should be found!");
 		}
 		
+		[Test]
+		public void ProtectedMemberVisibleWithImplicitThisReferenceTest()
+		{
+			string program = @"using System;
+class A : B {
+	void TestMethod(A a) {
+		
+	}
+}
+class B {
+	protected int member;
+}
+";
+			ArrayList results = CtrlSpaceResolveCSharp(program, 4, ExpressionContext.Default);
+			Assert.IsTrue(MemberExists(results, "member"), "member should be in completion lookup");
+			ResolveResult result = Resolve(program, "member", 4);
+			Assert.IsTrue(result != null && result.IsValid, "member should be found!");
+		}
+		
 		[Test]
 		public void ProtectedInvisibleMemberTest()
 		{
@@ -1270,11 +1289,50 @@ class B {
 			Assert.IsTrue(result != null && result.IsValid, "method should be found!");
 		}
 		
+		[Test]
+		public void ProtectedMethodVisibleWithImplicitThisReferenceTest()
+		{
+			string program = @"using System;
+class A : B {
+	void TestMethod(A a) {
+		
+	}
+}
+class B {
+	protected int Method();
+}
+";
+			ArrayList results = CtrlSpaceResolveCSharp(program, 4, ExpressionContext.Default);
+			Assert.IsTrue(MemberExists(results, "Method"), "method should be in completion lookup");
+			ResolveResult result = Resolve(program, "Method()", 4);
+			Assert.IsTrue(result != null && result.IsValid, "method should be found!");
+		}
+		
+		[Test]
+		public void ProtectedMethodVisibleWithImplicitThisReferenceConflictsWithClassNameTest()
+		{
+			string program = @"using System;
+class A : B {
+	void TestMethod(A a) {
+		
+	}
+}
+class B {
+	protected int Method();
+}
+class Method { }
+";
+			ArrayList results = CtrlSpaceResolveCSharp(program, 4, ExpressionContext.Default);
+			Assert.IsTrue(MemberExists(results, "Method"), "method should be in completion lookup");
+			ResolveResult result = Resolve(program, "Method()", 4);
+			Assert.IsTrue(result != null && result.IsValid, "method should be found!");
+		}
+		
 		bool MemberExists(ArrayList members, string name)
 		{
 			foreach (object o in members) {
 				IMember m = o as IMember;
-				if (m.Name == name) return true;
+				if (m != null && m.Name == name) return true;
 			}
 			return false;
 		}

src/Main/Base/Test/ReflectionLayerTests.cs

@@ -19,9 +19,64 @@ using NUnit.Framework;
 namespace ICSharpCode.SharpDevelop.Tests
 {
 	[TestFixture]
-	public class ReflectionLayerTests
+	public class ReflectionLayerTests : ReflectionOrCecilLayerTests
 	{
-		IProjectContent pc = ParserService.DefaultProjectContentRegistry.Mscorlib;
+		public ReflectionLayerTests()
+		{
+			pc = ParserService.DefaultProjectContentRegistry.Mscorlib;
+		}
+		
+		protected override IClass GetClass(Type type)
+		{
+			ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new DomAssemblyName[0], ParserService.DefaultProjectContentRegistry).AssemblyCompilationUnit;
+			IClass c = new ReflectionClass(cu, type, type.FullName, null);
+			cu.ProjectContent.AddClassToNamespaceList(c);
+			return c;
+		}
+	}
+	
+	[TestFixture]
+	public class ReflectionWithRoundTripLayerTests : ReflectionOrCecilLayerTests
+	{
+		public ReflectionWithRoundTripLayerTests()
+		{
+			pc = ParserService.DefaultProjectContentRegistry.Mscorlib;
+		}
+		
+		protected override IClass GetClass(Type type)
+		{
+			ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new DomAssemblyName[0], ParserService.DefaultProjectContentRegistry).AssemblyCompilationUnit;
+			IClass c = new ReflectionClass(cu, type, type.FullName, null);
+			cu.ProjectContent.AddClassToNamespaceList(c);
+			
+			MemoryStream memory = new MemoryStream();
+			DomPersistence.WriteProjectContent((ReflectionProjectContent)c.ProjectContent, memory);
+			
+			memory.Position = 0;
+			return DomPersistence.LoadProjectContent(memory, ParserService.DefaultProjectContentRegistry).Classes.Single();
+		}
+	}
+	
+	[TestFixture]
+	public class CecilLayerTests : ReflectionOrCecilLayerTests
+	{
+		public CecilLayerTests()
+		{
+			pc = CecilReader.LoadAssembly(typeof(object).Assembly.Location, ParserService.DefaultProjectContentRegistry);;
+		}
+		
+		protected override IClass GetClass(Type type)
+		{
+			IProjectContent pc = CecilReader.LoadAssembly(type.Assembly.Location, ParserService.DefaultProjectContentRegistry);
+			IClass c = (IClass)pc.GetElement(type.FullName);
+			Assert.IsNotNull(c);
+			return c;
+		}
+	}
+	
+	public abstract class ReflectionOrCecilLayerTests
+	{
+		protected IProjectContent pc;
 		
 		[Test]
 		public void InheritanceTest()
@@ -53,6 +108,16 @@ namespace ICSharpCode.SharpDevelop.Tests
 			}
 		}
 		
+		[Test]
+		public void GenericPropertyTest()
+		{
+			IClass c = pc.GetClass("System.Collections.Generic.Comparer", 1);
+			IProperty def = c.Properties.First(p => p.Name == "Default");
+			ConstructedReturnType crt = def.ReturnType.CastToConstructedReturnType();
+			Assert.AreEqual("System.Collections.Generic.Comparer", crt.FullyQualifiedName);
+			Assert.IsTrue(crt.TypeArguments[0].IsGenericReturnType);
+		}
+		
 		[Test]
 		public void ParameterComparisonTest()
 		{
@@ -114,27 +179,20 @@ namespace ICSharpCode.SharpDevelop.Tests
 			Assert.AreSame(c.DefaultReturnType, VoidReturnType.Instance, "VoidReturnType.Instance is c.DefaultReturnType");
 		}
 		
-		class TestClass<A, B> where A : B {
+		public class TestClass<A, B> where A : B {
 			public void TestMethod<K, V>(string param) where V: K where K: IComparable {}
 			
 			public void GetIndex<T>(T element) where T: IEquatable<T> {}
 		}
 		
+		protected abstract IClass GetClass(Type type);
+		
 		[Test]
 		public void ReflectionParserTest()
 		{
-			ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new DomAssemblyName[0], ParserService.DefaultProjectContentRegistry).AssemblyCompilationUnit;
-			IClass c = new ReflectionClass(cu, typeof(TestClass<,>), typeof(TestClass<,>).FullName, null);
-			cu.ProjectContent.AddClassToNamespaceList(c);
+			IClass c = GetClass(typeof(TestClass<,>));
 			
 			CheckClass(c);
-			MemoryStream memory = new MemoryStream();
-			DomPersistence.WriteProjectContent((ReflectionProjectContent)cu.ProjectContent, memory);
-			
-			memory.Position = 0;
-			foreach (IClass c2 in DomPersistence.LoadProjectContent(memory, ParserService.DefaultProjectContentRegistry).Classes) {
-				CheckClass(c2);
-			}
 		}
 		
 		void CheckClass(IClass c)

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/NRefactoryResolver.cs

@@ -572,7 +572,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					ResolveResult rr = ResolveMember(tmp.DefaultReturnType, identifier,
 					                                 identifierExpression.TypeArguments,
 					                                 identifierExpression.Parent is InvocationExpression,
-					                                 false, null);
+					                                 false, true);
 					if (rr != null && rr.IsValid)
 						return rr;
 					// also try to resolve the member in outer classes

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/ResolveVisitor.cs

@@ -272,6 +272,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 			
 			ResolveResult rr = Resolve(invocationExpression.TargetObject);
+			MixedResolveResult mixedRR = rr as MixedResolveResult;
+			if (mixedRR != null) {
+				rr = mixedRR.PrimaryResult;
+			}
 			MethodGroupResolveResult mgrr = rr as MethodGroupResolveResult;
 			if (mgrr != null) {
 				if (resolver.Language == SupportedLanguage.VBNet && mgrr.Methods.All(mg => mg.Count == 0))

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/ReflectionReturnType.cs

@@ -28,19 +28,24 @@ namespace ICSharpCode.SharpDevelop.Dom.ReflectionLayer
 		}
 		
 		public static IReturnType Create(IProjectContent pc, IEntity member, Type type, bool createLazyReturnType)
+		{
+			return Create(pc, member, type, createLazyReturnType, true);
+		}
+		
+		static IReturnType Create(IProjectContent pc, IEntity member, Type type, bool createLazyReturnType, bool forceGenericType)
 		{
 			if (type.IsByRef) {
 				// TODO: Use ByRefRefReturnType
 				return Create(pc, member, type.GetElementType(), createLazyReturnType);
 			} else if (type.IsArray) {
 				return new ArrayReturnType(pc, Create(pc, member, type.GetElementType(), createLazyReturnType), type.GetArrayRank());
-			} else if (type.IsGenericType && !type.IsGenericTypeDefinition) {
+			} else if (type.IsGenericType && (forceGenericType || !type.IsGenericTypeDefinition)) {
 				Type[] args = type.GetGenericArguments();
 				List<IReturnType> para = new List<IReturnType>(args.Length);
 				for (int i = 0; i < args.Length; ++i) {
 					para.Add(Create(pc, member, args[i], createLazyReturnType));
 				}
-				return new ConstructedReturnType(Create(pc, member, type.GetGenericTypeDefinition(), createLazyReturnType), para);
+				return new ConstructedReturnType(Create(pc, member, type.GetGenericTypeDefinition(), createLazyReturnType, false), para);
 			} else if (type.IsGenericParameter) {
 				IClass c = (member is IClass) ? (IClass)member : (member is IMember) ? ((IMember)member).DeclaringType : null;
 				if (c != null && type.GenericParameterPosition < c.TypeParameters.Count) {