Show "value" in Ctrl+Space completion list inside property setters.

Fixed tooltip + go to definition for the type in property definitions like "public Color Color".

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

src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs

@@ -203,7 +203,7 @@ namespace Grunwald.BooBinding.CodeCompletion
 				return new NamespaceResolveResult(callingClass, callingMember, "");
 			}
 			
-			ResolveResult rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(callingClass, callingMember as IMethodOrProperty, this.caretLine, this.caretColumn, expressionResult.Expression);
+			ResolveResult rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(callingClass, callingMember as IMethodOrProperty, this.caretLine, this.caretColumn, expressionResult);
 			if (rr != null) return rr;
 			
 			AST.Expression expr;

src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/NRefactoryAstCacheService.cs

@@ -223,7 +223,7 @@ namespace Hornung.ResourceToolkit.Resolver
 					// code belonging to this expression is unavailable.
 					expressionString = resolver.LanguageProperties.CodeGenerator.GenerateCode(expression, String.Empty);
 				}
-				if ((rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(resolver.CallingClass, resolver.CallingMember as IMethodOrProperty, caretLine, caretColumn, expressionString)) != null) {
+				if ((rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(resolver.CallingClass, resolver.CallingMember as IMethodOrProperty, caretLine, caretColumn, new ExpressionResult(expressionString))) != null) {
 					return rr;
 				}
 			}

src/Main/Base/Project/Src/TextEditor/Gui/Editor/CompletionWindow/CtrlSpaceCompletionDataProvider.cs

@@ -6,6 +6,7 @@
 // </file>
 
 using System;
+using System.Collections;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.TextEditor;
 
@@ -76,7 +77,8 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				if (charTyped != '\0') {
 					preSelection = null;
 				}
-				AddResolveResults(ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context), expressionResult.Context);
+				ArrayList results = ParserService.CtrlSpace(caretLineNumber, caretColumn, fileName, textArea.Document.TextContent, expressionResult.Context);
+				AddResolveResults(results, expressionResult.Context);
 			}
 		}
 	}

src/Main/Base/Project/Src/Util/DebugTimer.cs

@@ -36,6 +36,7 @@ namespace ICSharpCode.SharpDevelop
 		{
 			stopWatch.Stop();
 			LoggingService.Debug("\"" + desc + "\" took " + (stopWatch.ElapsedMilliseconds) + " ms");
+			stopWatch.Reset();
 		}
 	}
 }

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -81,12 +81,17 @@ namespace ICSharpCode.SharpDevelop.Tests
 		}
 		
 		public ResolveResult Resolve(string program, string expression, int line)
+		{
+			return Resolve(program, expression, line, 0, ExpressionContext.Default);
+		}
+		
+		public ResolveResult Resolve(string program, string expression, int line, int column, ExpressionContext context)
 		{
 			AddCompilationUnit(Parse("a.cs", program), "a.cs");
 			
 			NRefactoryResolver resolver = new NRefactoryResolver(lastPC, LanguageProperties.CSharp);
-			return resolver.Resolve(new ExpressionResult(expression),
-			                        line, 0,
+			return resolver.Resolve(new ExpressionResult(expression, context),
+			                        line, column,
 			                        "a.cs",
 			                        program);
 		}
@@ -226,10 +231,21 @@ class A {
 			Assert.AreEqual("System.Collections.ArrayList", result.ResolvedType.FullyQualifiedName);
 		}
 		
+		[Test]
+		public void PropertyTypeConflictTestResolveInTypeContext()
+		{
+			TypeResolveResult result = (TypeResolveResult)Resolve(arrayListConflictProgram, "ArrayList", 4, 0, ExpressionContext.Type);
+			Assert.AreEqual("System.Collections.ArrayList", result.ResolvedClass.FullyQualifiedName);
+			
+			result = (TypeResolveResult)Resolve(arrayListConflictProgram, "ArrayList", 8, 10, ExpressionContext.Type);
+			Assert.AreEqual("System.Collections.ArrayList", result.ResolvedClass.FullyQualifiedName);
+		}
+		
 		[Test]
 		public void PropertyTypeConflictCompletionResultTest()
 		{
 			ResolveResult result = Resolve(arrayListConflictProgram, "ArrayList", 4);
+			Assert.IsTrue(result is MixedResolveResult);
 			// CC should offer both static and non-static results
 			ArrayList list = result.GetCompletionData(lastPC);
 			bool ok = false;
@@ -491,6 +507,17 @@ class A {
 			Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName);
 			MemberResolveResult mrr = Resolve<MemberResolveResult>(program, "value.ToString()", 4);
 			Assert.AreEqual("System.String.ToString", mrr.ResolvedMember.FullyQualifiedName);
+			
+			int valueParameterCount = 0;
+			foreach (object o in CtrlSpaceResolveCSharp(program, 4)) {
+				IField f = o as IField;
+				if (f != null && f.Name == "value") {
+					valueParameterCount++;
+					Assert.IsTrue(f.IsParameter);
+					Assert.AreEqual("System.String", f.ReturnType.FullyQualifiedName);
+				}
+			}
+			Assert.IsTrue(valueParameterCount == 1);
 		}
 		
 		[Test]
@@ -657,6 +684,14 @@ namespace Root.Child {
 			Assert.AreEqual("Root.Alpha", result.ResolvedType.FullyQualifiedName);
 		}
 		
+		ArrayList CtrlSpaceResolveCSharp(string program, int line)
+		{
+			AddCompilationUnit(Parse("a.cs", program), "a.cs");
+			
+			NRefactoryResolver resolver = new NRefactoryResolver(lastPC, LanguageProperties.CSharp);
+			return resolver.CtrlSpace(line, 0, "a.cs", program, ExpressionContext.Default);
+		}
+		
 		[Test]
 		public void ParentNamespaceCtrlSpace()
 		{
@@ -672,10 +707,7 @@ namespace Root.Child {
   }
 }
 ";
-			AddCompilationUnit(Parse("a.cs", program), "a.cs");
-			
-			NRefactoryResolver resolver = new NRefactoryResolver(lastPC, LanguageProperties.CSharp);
-			ArrayList m = resolver.CtrlSpace(7, 0, "a.cs", program, ExpressionContext.Default);
+			ArrayList m = CtrlSpaceResolveCSharp(program, 7);
 			Assert.IsTrue(TypeExists(m, "Beta"), "Meta must exist");
 			Assert.IsTrue(TypeExists(m, "Alpha"), "Alpha must exist");
 		}

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

@@ -152,8 +152,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		[Obsolete()]
 		public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, string expression)
 		{
+			return GetResultFromDeclarationLine(callingClass, callingMember, caretLine, caretColumn, new ExpressionResult(expression));
+		}
+		
+		public static ResolveResult GetResultFromDeclarationLine(IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, ExpressionResult expressionResult)
+		{
+			string expression = expressionResult.Expression;
 			if (callingClass == null) return null;
 			int pos = expression.IndexOf('(');
 			if (pos >= 0) {
@@ -165,11 +172,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 			{
 				return new TypeResolveResult(callingClass, callingMember, callingClass);
 			}
-			if (callingMember != null
-			    && !callingMember.BodyRegion.IsInside(caretLine, caretColumn)
-			    && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name))
-			{
-				return new MemberResolveResult(callingClass, callingMember, callingMember);
+			if (expressionResult.Context != ExpressionContext.Type) {
+				if (callingMember != null
+				    && !callingMember.BodyRegion.IsInside(caretLine, caretColumn)
+				    && callingClass.ProjectContent.Language.NameComparer.Equals(expression, callingMember.Name))
+				{
+					return new MemberResolveResult(callingClass, callingMember, callingMember);
+				}
 			}
 			return null;
 		}

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

@@ -196,7 +196,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			
 			RunLookupTableVisitor(fileContent);
 			
-			ResolveResult rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(callingClass, callingMember as IMethodOrProperty, caretLine, caretColumn, expression);
+			ResolveResult rr = CtrlSpaceResolveHelper.GetResultFromDeclarationLine(callingClass, callingMember as IMethodOrProperty, caretLine, caretColumn, expressionResult);
 			if (rr != null) return rr;
 			
 			return ResolveInternal(expr, expressionResult.Context);
@@ -1052,6 +1052,13 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					}
 				}
 			}
+			if (callingMember is IProperty) {
+				IProperty property = (IProperty)callingMember;
+				if (property.SetterRegion.IsInside(caretLine, caretColumn)) {
+					result.Add(new DefaultField.ParameterField(property.ReturnType, "value", property.Region, callingClass));
+				}
+			}
+			
 			CtrlSpaceResolveHelper.AddImportedNamespaceContents(result, cu, callingClass);
 			return result;
 		}