Improved performance of code completion on variables with expensive type lookups (range variables, elements defined in XAML)

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

src/Main/Base/Test/Utils/MockDefaultReturnType.cs

@@ -154,5 +154,10 @@ namespace ICSharpCode.SharpDevelop.Tests.Utils
 				throw new NotImplementedException();
 			}
 		}
+		
+		public IReturnType GetDirectReturnType()
+		{
+			return this;
+		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/ICSharpCode.SharpDevelop.Dom.csproj

@@ -98,6 +98,7 @@
     <Compile Include="Src\Implementations\ReferenceReturnType.cs" />
     <Compile Include="Src\Implementations\SearchClassReturnType.cs" />
     <Compile Include="Src\Implementations\SystemTypes.cs" />
+    <Compile Include="Src\Implementations\UnknownReturnType.cs" />
     <Compile Include="Src\Interfaces\ExplicitInterfaceImplementation.cs" />
     <Compile Include="Src\Interfaces\IDomProgressMonitor.cs" />
     <Compile Include="Src\Interfaces\IFreezable.cs" />

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/AbstractReturnType.cs

@@ -131,5 +131,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		
 		public virtual bool? IsReferenceType { get { return null; } }
+		
+		public virtual IReturnType GetDirectReturnType()
+		{
+			return this;
+		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ArrayReturnType.cs

@@ -42,6 +42,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.dimensions = dimensions;
 		}
 		
+		public override IReturnType GetDirectReturnType()
+		{
+			IReturnType newElementType = elementType.GetDirectReturnType();
+			if (newElementType == elementType)
+				return this;
+			else
+				return new ArrayReturnType(pc, newElementType, dimensions);
+		}
+		
 		public override bool Equals(IReturnType rt)
 		{
 			if (rt == null || !rt.IsArrayReturnType) return false;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ConstructedReturnType.cs

@@ -63,6 +63,23 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return this.DotNetName.GetHashCode();
 		}
 		
+		public override IReturnType GetDirectReturnType()
+		{
+			IReturnType newBaseType = baseType.GetDirectReturnType();
+			IReturnType[] newTypeArguments = new IReturnType[typeArguments.Count];
+			bool typeArgumentsChanged = false;
+			for (int i = 0; i < typeArguments.Count; i++) {
+				if (typeArguments[i] != null)
+					newTypeArguments[i] = typeArguments[i].GetDirectReturnType();
+				if (typeArguments[i] != newTypeArguments[i])
+					typeArgumentsChanged = true;
+			}
+			if (baseType == newBaseType && !typeArgumentsChanged)
+				return this;
+			else
+				return new ConstructedReturnType(newBaseType, newTypeArguments);
+		}
+		
 		public override IReturnType BaseType {
 			get {
 				return baseType;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DecoratingReturnType.cs

@@ -24,5 +24,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		
 		public abstract override T CastToDecoratingReturnType<T>();
+		
+		public override IReturnType GetDirectReturnType()
+		{
+			return this;
+		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/PointerReturnType.cs

@@ -37,6 +37,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override IReturnType GetDirectReturnType()
+		{
+			IReturnType newBaseType = baseType.GetDirectReturnType();
+			if (newBaseType == baseType)
+				return this;
+			else
+				return new PointerReturnType(newBaseType);
+		}
+		
 		public override bool Equals(IReturnType rt)
 		{
 			if (rt == null) return false;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ProxyReturnType.cs

@@ -226,5 +226,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return tmp;
 			}
 		}
+		
+		public virtual IReturnType GetDirectReturnType()
+		{
+			IReturnType baseType = BaseType;
+			IReturnType tmp = (baseType != null && TryEnter()) ? baseType.GetDirectReturnType() : UnknownReturnType.Instance;
+			Leave();
+			return tmp;
+		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/ReferenceReturnType.cs

@@ -21,6 +21,17 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.baseType = baseType;
 		}
 		
+		public override IReturnType GetDirectReturnType()
+		{
+			if (baseType == null)
+				return this;
+			IReturnType newBaseType = baseType.GetDirectReturnType();
+			if (newBaseType == baseType)
+				return this;
+			else
+				return new ReferenceReturnType(newBaseType);
+		}
+		
 		public override IReturnType BaseType {
 			get { return baseType; }
 		}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/UnknownReturnType.cs

@@ -0,0 +1,22 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <author name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	sealed class UnknownReturnType : ProxyReturnType
+	{
+		public static readonly UnknownReturnType Instance = new UnknownReturnType();
+		
+		public override IReturnType BaseType {
+			get {
+				return null;
+			}
+		}
+	}
+}

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Interfaces/IReturnType.cs

@@ -127,6 +127,23 @@ namespace ICSharpCode.SharpDevelop.Dom
 		bool IsConstructedReturnType { get; }
 		ConstructedReturnType CastToConstructedReturnType();
 		
+		/// <summary>
+		/// Gets whether the type is a reference type or value type.
+		/// </summary>
+		/// <returns>
+		/// true, if the type is a reference type.
+		/// false, if the type is a value type.
+		/// null, if the type is not known (e.g. generic type argument or type not found)
+		/// </returns>
 		bool? IsReferenceType { get; }
+		
+		/// <summary>
+		/// Gets an identical return type that binds directly to the underlying class, so
+		/// that repeatedly calling methods does not cause repeated class lookups.
+		/// The direct return type will always point to the old version of the class, so don't
+		/// store direct return types!
+		/// </summary>
+		/// <returns>This method never returns null.</returns>
+		IReturnType GetDirectReturnType();
 	}
 }

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

@@ -112,6 +112,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			if (callingClass == null)
 				throw new ArgumentNullException("callingClass");
 			
+			// convert resolvedType into direct type to speed up the IsApplicable lookups
+			resolvedType = resolvedType.GetDirectReturnType();
+			
 			foreach (IMethodOrProperty mp in CtrlSpaceResolveHelper.FindAllExtensions(language, callingClass)) {
 				TryAddExtension(language, res, mp, resolvedType);
 			}