Limit length of entry names in clipboard ring.

Fixed code completion on generic new expressions ("var a = new List<string>();")
Make ResolveResult immutable because it can be cached by the resolver.

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

src/Main/Base/Project/Src/Gui/Components/SideBar/TextEditorSideBar.cs

@@ -84,7 +84,10 @@ namespace ICSharpCode.SharpDevelop.Gui
 		public void PutInClipboardRing(string text)
 		{
 			if (clipboardRing != null) {
-				clipboardRing.Items.Add("Text:" + text.Trim(), text);
+				string shortenedText = text.Trim();
+				if (shortenedText.Length > 50)
+					shortenedText = shortenedText.Substring(0, 47) + "...";
+				clipboardRing.Items.Add("Text:" + shortenedText, text);
 				if (clipboardRing.Items.Count > 20) {
 					clipboardRing.Items.RemoveAt(0);
 				}

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -266,6 +266,21 @@ interface IInterface2 {
 			Assert.IsNull(result, "result");
 		}
 		
+		[Test]
+		public void GenericObjectCreation()
+		{
+			string program = @"using System.Collections.Generic;
+class A {
+	static void Main() {
+		
+	}
+}
+";
+			MemberResolveResult result = Resolve<MemberResolveResult>(program, "new List<string>()", 4);
+			Assert.AreEqual("System.Collections.Generic.List.#ctor", result.ResolvedMember.FullyQualifiedName);
+			Assert.AreEqual("System.Collections.Generic.List{System.String}", result.ResolvedType.DotNetName);
+		}
+		
 		[Test]
 		public void InvalidConstructorCallTest()
 		{

src/Main/Base/Test/OverloadFinding.cs

@@ -59,9 +59,23 @@ namespace ICSharpCode.SharpDevelop.Tests
 			Test("(null)", 1, overloads);
 		}
 		
+		[Test] public void Generic()
+		{
+			string program = "class T<A> {}   class T<A, B> {}";
+			string[] overloads = {"(T<int> a)", "(T<int, string> a)", "(T<char, string> a)"};
+			Test("(new T<int>())", program, 0, overloads);
+			Test("(new T<int, string>())", program, 1, overloads);
+			Test("(new T<char, string>())", program, 2, overloads);
+		}
+		
 		NRefactoryResolverTests nrrt = new NRefactoryResolverTests();
 		
 		void Test(string callExpr, int num, params string[] signatures)
+		{
+			Test(callExpr, "", num, signatures);
+		}
+		
+		void Test(string callExpr, string extraCode, int num, params string[] signatures)
 		{
 			StringBuilder b = new StringBuilder();
 			int lineNumber = 0;
@@ -81,6 +95,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 				++lineNumber; b.AppendLine(" }");
 			}
 			b.AppendLine("}");
+			b.Append(extraCode);
 			MemberResolveResult mrr = nrrt.Resolve<MemberResolveResult>(b.ToString(), "Method" + callExpr, callPosition);
 			string msg = "wrong overload: ";
 			for (int i = 0; i < positions.Length; i++) {

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

@@ -210,9 +210,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// <summary>
 		/// Finds the correct overload according to the C# specification.
 		/// </summary>
-		/// <param name="methods">List with the methods to check.<br/>
-		/// <b>Generic methods in the input type are replaced by methods with have the types substituted!</b>
-		/// </param>
+		/// <param name="methods">List with the methods to check.</param>
 		/// <param name="arguments">The types of the arguments passed to the method.</param>
 		/// <param name="resultIsAcceptable">Out parameter. Will be true if the resulting method
 		/// is an acceptable match, false if the resulting method is just a guess and will lead
@@ -220,9 +218,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// <returns>The method that will be called.</returns>
 		public static IMethod FindOverload(IList<IMethod> methods, IReturnType[] arguments, out bool resultIsAcceptable)
 		{
+			if (methods == null)
+				throw new ArgumentNullException("methods");
 			resultIsAcceptable = false;
 			if (methods.Count == 0)
 				return null;
+			methods = methods.ToArray();
 			int[] ranking = RankOverloads(methods, arguments, false, out resultIsAcceptable);
 			int bestRanking = -1;
 			int best = 0;
@@ -274,6 +275,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 		                                  bool allowAdditionalArguments,
 		                                  out bool acceptableMatch)
 		{
+			if (list == null)
+				throw new ArgumentNullException("list");
+			if (arguments == null)
+				throw new ArgumentNullException("arguments");
+			
 			acceptableMatch = false;
 			if (list.Count == 0) return new int[] {};
 			

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

@@ -69,6 +69,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			ResolveResult rr;
 			if (!cachedResults.TryGetValue(expression, out rr)) {
 				rr = (ResolveResult)expression.AcceptVisitor(this, null);
+				if (rr != null)
+					rr.Freeze();
 				cachedResults[expression] = rr;
 			}
 			return rr;
@@ -430,11 +432,21 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				if (rt == null)
 					return null;
 				
-				return ResolveConstructorOverload(rt.GetUnderlyingClass(), objectCreateExpression.Parameters)
+				return ResolveConstructorOverload(rt, objectCreateExpression.Parameters)
 					?? CreateResolveResult(rt);
 			}
 		}
 		
+		internal ResolveResult ResolveConstructorOverload(IReturnType rt, List<Expression> arguments)
+		{
+			if (rt == null)
+				return null;
+			ResolveResult rr = ResolveConstructorOverload(rt.GetUnderlyingClass(), arguments);
+			if (rr != null)
+				rr.ResolvedType = rt;
+			return rr;
+		}
+		
 		internal ResolveResult ResolveConstructorOverload(IClass c, List<Expression> arguments)
 		{
 			if (c == null)

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

@@ -19,7 +19,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// The ResolveResult specified the location where Resolve was called (Class+Member)
 	/// and the type of the resolved expression.
 	/// </summary>
-	public class ResolveResult : ICloneable
+	public class ResolveResult : AbstractFreezable, ICloneable
 	{
 		IClass callingClass;
 		IMember callingMember;
@@ -60,7 +60,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// </summary>
 		public IReturnType ResolvedType {
 			get { return resolvedType; }
-			set { resolvedType = value; }
+			set {
+				CheckBeforeMutation();
+				resolvedType = value;
+			}
 		}
 		
 		public virtual ResolveResult Clone()
@@ -508,10 +511,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 	#endregion
 	
 	#region MethodResolveResult
-	public class MethodGroup : IList<IMethod>
+	public class MethodGroup : AbstractFreezable, IList<IMethod>
 	{
-		public bool IsExtensionMethodGroup { get; set; }
 		IList<IMethod> innerList;
+		bool isExtensionMethodGroup;
 		
 		public MethodGroup() : this(new List<IMethod>())
 		{
@@ -524,6 +527,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.innerList = innerList;
 		}
 		
+		public bool IsExtensionMethodGroup {
+			get { return isExtensionMethodGroup; }
+			set {
+				CheckBeforeMutation();
+				isExtensionMethodGroup = value;
+			}
+		}
+		
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			innerList = FreezeList(innerList);
+		}
+		
 		public IMethod this[int index] {
 			get { return innerList[index]; }
 			set { innerList[index] = value; }
@@ -636,6 +653,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return new MethodGroupResolveResult(this.CallingClass, this.CallingMember, this.ContainingType, this.Name, this.Methods);
 		}
 		
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			if (possibleMethods != null) {
+				possibleMethods = FreezeList(possibleMethods);
+			}
+		}
+		
 		/// <summary>
 		/// Gets the name of the method.
 		/// </summary>
@@ -656,11 +681,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public IList<MethodGroup> Methods {
 			get {
 				if (possibleMethods == null) {
-					possibleMethods = new MethodGroup[] {
-						new MethodGroup(
-							containingType.GetMethods().FindAll((IMethod m) => m.Name == this.name)
-						)
-					};
+					possibleMethods = FreezeList(
+						new MethodGroup[] {
+							new MethodGroup(
+								containingType.GetMethods().FindAll((IMethod m) => m.Name == this.name)
+							)
+						});
 				}
 				return possibleMethods;
 			}
@@ -689,7 +715,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// <summary>
 	/// Is used for "MyBase" or "Me" in VB constructors to show "New" in the completion list.
 	/// </summary>
-	public sealed class VBBaseOrThisReferenceInConstructorResolveResult : ResolveResult
+	public class VBBaseOrThisReferenceInConstructorResolveResult : ResolveResult
 	{
 		public VBBaseOrThisReferenceInConstructorResolveResult(IClass callingClass, IMember callingMember, IReturnType referencedType)
 			: base(callingClass, callingMember, referencedType)
@@ -718,7 +744,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// Is used for "base"/"MyBase" expression.
 	/// The completion list always shows protected members.
 	/// </summary>
-	public sealed class BaseResolveResult : ResolveResult
+	public class BaseResolveResult : ResolveResult
 	{
 		public BaseResolveResult(IClass callingClass, IMember callingMember, IReturnType baseClassType)
 			: base(callingClass, callingMember, baseClassType)