Added BoundTypeParameter to Dom to represent the inferred types of a generic method invocation.

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

src/Main/Base/Project/Src/Services/AmbienceService/NetAmbience.cs

@@ -51,7 +51,7 @@ namespace ICSharpCode.SharpDevelop
 				builder.Append('<');
 				for (int i = 0; i < c.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(c.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(c.TypeParameters[i]));
 				}
 				builder.Append('>');
 			}
@@ -176,6 +176,14 @@ namespace ICSharpCode.SharpDevelop
 			return builder.ToString();
 		}
 		
+		string ConvertTypeParameter(ITypeParameter tp)
+		{
+			if (tp.BoundTo != null)
+				return Convert(tp.BoundTo);
+			else
+				return tp.Name;
+		}
+		
 		public override string Convert(IMethod m)
 		{
 			StringBuilder builder = new StringBuilder();
@@ -195,7 +203,7 @@ namespace ICSharpCode.SharpDevelop
 				builder.Append('<');
 				for (int i = 0; i < m.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(m.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(m.TypeParameters[i]));
 				}
 				builder.Append('>');
 			}

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

@@ -72,6 +72,7 @@
     <Compile Include="Src\Implementations\AnonymousMethodReturnType.cs" />
     <Compile Include="Src\Implementations\ArrayReturnType.cs" />
     <Compile Include="Src\Implementations\AttributeReturnType.cs" />
+    <Compile Include="Src\Implementations\BoundTypeParameter.cs" />
     <Compile Include="Src\Implementations\CombinedReturnType.cs" />
     <Compile Include="Src\Implementations\CompoundClass.cs" />
     <Compile Include="Src\Implementations\ConstructedReturnType.cs" />

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CSharp/CSharpAmbience.cs

@@ -160,7 +160,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append('<');
 				for (int i = 0; i < c.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(c.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(c.TypeParameters[i]));
 				}
 				builder.Append('>');
 			}
@@ -416,7 +416,7 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 				builder.Append('<');
 				for (int i = 0; i < m.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(m.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(m.TypeParameters[i]));
 				}
 				builder.Append('>');
 			}
@@ -453,6 +453,14 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 			return builder.ToString();
 		}
 		
+		string ConvertTypeParameter(ITypeParameter tp)
+		{
+			if (tp.BoundTo != null)
+				return Convert(tp.BoundTo);
+			else
+				return tp.Name;
+		}
+		
 		public override string ConvertEnd(IMethod m)
 		{
 			return "}";

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/CSharp/OverloadResolution.cs

@@ -151,16 +151,28 @@ namespace ICSharpCode.SharpDevelop.Dom.CSharp
 					if (!success) {
 						candidate.Status = CandidateStatus.TypeInferenceFailed;
 					}
-					if (typeArguments != null) {
-						// apply inferred type arguments
-						method = (IMethod)method.CreateSpecializedMember();
-						method.ReturnType = ConstructedReturnType.TranslateType(method.ReturnType, typeArguments, true);
-						for (int i = 0; i < method.Parameters.Count; ++i) {
-							method.Parameters[i].ReturnType = ConstructedReturnType.TranslateType(method.Parameters[i].ReturnType, typeArguments, true);
-						}
-						candidate.Method = method;
-					}
+					candidate.Method = ApplyTypeArgumentsToMethod(method, typeArguments);
+				}
+			}
+		}
+		
+		static IMethod ApplyTypeArgumentsToMethod(IMethod genericMethod, IList<IReturnType> typeArguments)
+		{
+			if (typeArguments != null && typeArguments.Count > 0) {
+				// apply inferred type arguments
+				IMethod method = (IMethod)genericMethod.CreateSpecializedMember();
+				method.ReturnType = ConstructedReturnType.TranslateType(method.ReturnType, typeArguments, true);
+				for (int i = 0; i < method.Parameters.Count; ++i) {
+					method.Parameters[i].ReturnType = ConstructedReturnType.TranslateType(method.Parameters[i].ReturnType, typeArguments, true);
+				}
+				for (int i = 0; i < Math.Min(typeArguments.Count, method.TypeParameters.Count); i++) {
+					var tp = new BoundTypeParameter(method.TypeParameters[i], method.DeclaringType, method);
+					tp.BoundTo = typeArguments[i];
+					method.TypeParameters[i] = tp;
 				}
+				return method;
+			} else {
+				return genericMethod;
 			}
 		}
 		

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

@@ -0,0 +1,95 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <author name="Daniel Grunwald"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// A type parameter that was bound to a concrete type.
+	/// </summary>
+	public sealed class BoundTypeParameter : AbstractFreezable, ITypeParameter
+	{
+		readonly ITypeParameter baseTypeParameter;
+		readonly IMethod owningMethod;
+		readonly IClass owningClass;
+		IReturnType boundTo;
+		
+		public BoundTypeParameter(ITypeParameter baseTypeParameter, IClass owningClass)
+			: this(baseTypeParameter, owningClass, null)
+		{
+		}
+		
+		public BoundTypeParameter(ITypeParameter baseTypeParameter, IClass owningClass, IMethod owningMethod)
+		{
+			if (owningClass == null)
+				throw new ArgumentNullException("owningClass");
+			if (baseTypeParameter == null)
+				throw new ArgumentNullException("baseTypeParameter");
+			this.baseTypeParameter = baseTypeParameter;
+			this.owningMethod = owningMethod;
+			this.owningClass = owningClass;
+		}
+		
+		protected override void FreezeInternal()
+		{
+			base.FreezeInternal();
+			baseTypeParameter.Freeze();
+			owningMethod.Freeze();
+			owningClass.Freeze();
+		}
+		
+		public string Name {
+			get { return baseTypeParameter.Name; }
+		}
+		
+		public int Index {
+			get { return baseTypeParameter.Index; }
+		}
+		
+		public IList<IAttribute> Attributes {
+			get { return baseTypeParameter.Attributes; }
+		}
+		
+		public IMethod Method {
+			get { return owningMethod; }
+		}
+		
+		public IClass Class {
+			get { return owningClass; }
+		}
+		
+		public IList<IReturnType> Constraints {
+			get { return baseTypeParameter.Constraints; }
+		}
+		
+		public bool HasConstructableConstraint {
+			get { return baseTypeParameter.HasConstructableConstraint; }
+		}
+		
+		public bool HasReferenceTypeConstraint {
+			get { return baseTypeParameter.HasReferenceTypeConstraint; }
+		}
+		
+		public bool HasValueTypeConstraint {
+			get { return baseTypeParameter.HasValueTypeConstraint; }
+		}
+		
+		public IReturnType BoundTo {
+			get { return boundTo; }
+			set {
+				CheckBeforeMutation();
+				boundTo = value;
+			}
+		}
+		
+		public ITypeParameter UnboundTypeParameter {
+			get { return baseTypeParameter.UnboundTypeParameter; }
+		}
+	}
+}

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

@@ -82,7 +82,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
 			p.parameters = DefaultParameter.Clone(this.Parameters);
-			p.typeParameters = this.typeParameters;
+			p.typeParameters = new List<ITypeParameter>(this.typeParameters);
 			p.CopyDocumentationFrom(this);
 			p.documentationTag = DocumentationTag;
 			p.isExtensionMethod = this.isExtensionMethod;

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

@@ -17,10 +17,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 	{
 		public static readonly IList<ITypeParameter> EmptyTypeParameterList = EmptyList<ITypeParameter>.Instance;
 		
-		string name;
-		IMethod method;
-		IClass targetClass;
-		int index;
+		readonly string name;
+		readonly IMethod method;
+		readonly IClass targetClass;
+		readonly int index;
 		IList<IReturnType> constraints = new List<IReturnType>();
 		
 		protected override void FreezeInternal()
@@ -178,5 +178,21 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			return c;
 		}
+		
+		/// <summary>
+		/// Gets the type that was used to bind this type parameter.
+		/// This property returns null for generic methods/classes, it
+		/// is non-null only for constructed versions of generic methods.
+		/// </summary>
+		public virtual IReturnType BoundTo {
+			get { return null; }
+		}
+		
+		/// <summary>
+		/// If this type parameter was bound, returns the unbound version of it.
+		/// </summary>
+		public virtual ITypeParameter UnboundTypeParameter {
+			get { return this; }
+		}
 	}
 }

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

@@ -20,6 +20,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// </summary>
 		string Name { get; }
 		
+		/// <summary>
+		/// Gets the index of the type parameter in the type parameter list of the owning method/class.
+		/// </summary>
 		int Index { get; }
 		
 		IList<IAttribute> Attributes { get; }
@@ -35,7 +38,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// When the type parameter is defined for a method, this is the class containing
 		/// that method.
 		/// </summary>
-		IClass Class  { get; }
+		IClass Class { get; }
 		
 		/// <summary>
 		/// Gets the contraints of this type parameter.
@@ -56,5 +59,17 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// Gets if the type parameter has the 'struct' constraint.
 		/// </summary>
 		bool HasValueTypeConstraint { get; }
+		
+		/// <summary>
+		/// Gets the type that was used to bind this type parameter.
+		/// This property returns null for generic methods/classes, it
+		/// is non-null only for constructed versions of generic methods.
+		/// </summary>
+		IReturnType BoundTo { get; }
+		
+		/// <summary>
+		/// If this type parameter was bound, returns the unbound version of it.
+		/// </summary>
+		ITypeParameter UnboundTypeParameter { get; }
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/VBNet/VBNetAmbience.cs

@@ -151,7 +151,7 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				builder.Append("(Of ");
 				for (int i = 0; i < c.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(c.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(c.TypeParameters[i]));
 				}
 				builder.Append(')');
 			}
@@ -428,7 +428,7 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 				builder.Append("(Of ");
 				for (int i = 0; i < m.TypeParameters.Count; ++i) {
 					if (i > 0) builder.Append(", ");
-					builder.Append(m.TypeParameters[i].Name);
+					builder.Append(ConvertTypeParameter(m.TypeParameters[i]));
 				}
 				builder.Append(')');
 			}
@@ -457,6 +457,14 @@ namespace ICSharpCode.SharpDevelop.Dom.VBNet
 			return builder.ToString();
 		}
 		
+		string ConvertTypeParameter(ITypeParameter tp)
+		{
+			if (tp.BoundTo != null)
+				return Convert(tp.BoundTo);
+			else
+				return tp.Name;
+		}
+		
 		public override string ConvertEnd(IMethod m)
 		{
 			if (m == null)