Worked on code completion for generics.

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

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

@@ -643,6 +643,9 @@
     <Compile Include="Src\Dom\Implementations\ProxyReturnType.cs" />
     <Compile Include="Src\Dom\Implementations\DefaultReturnType.cs" />
     <Compile Include="Src\Dom\Implementations\LazyReturnType.cs" />
+    <Compile Include="Src\Dom\Implementations\GenericReturnType.cs" />
+    <Compile Include="Src\Dom\Implementations\ArrayReturnType.cs" />
+    <Compile Include="Src\Dom\Implementations\SpecificReturnType.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj">

src/Main/Base/Project/Src/Dom/IMember.cs

@@ -9,7 +9,7 @@ using System.Reflection;
 
 namespace ICSharpCode.SharpDevelop.Dom
 {
-	public interface IMember : IDecoration
+	public interface IMember : IDecoration, ICloneable
 	{
 		string FullyQualifiedName {
 			get;

src/Main/Base/Project/Src/Dom/IParameter.cs

@@ -19,6 +19,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 
 		IReturnType ReturnType {
 			get;
+			set;
 		}
 
 		List<IAttribute> Attributes {

src/Main/Base/Project/Src/Dom/IReturnType.cs

@@ -30,9 +30,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		/// <summary>
 		/// Gets the array ranks of the return type.
-		/// When the return type is not an array, this property returns null.
+		/// When the return type is not an array, this property returns 0.
 		/// </summary>
-		int[] ArrayDimensions {
+		int ArrayDimensions {
 			get;
 		}
 		

src/Main/Base/Project/Src/Dom/Implementations/AbstractMember.cs

@@ -36,5 +36,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public AbstractMember(IClass declaringType, string name) : base(declaringType, name)
 		{
 		}
+		
+		public abstract IMember Clone();
+		
+		object ICloneable.Clone()
+		{
+			return this.Clone();
+		}
 	}
 }

src/Main/Base/Project/Src/Dom/Implementations/AbstractReturnType.cs

@@ -19,6 +19,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public abstract List<IEvent>    GetEvents();
 		public abstract List<IIndexer>  GetIndexers();
 		
+		public override bool Equals(object o)
+		{
+			AbstractReturnType rt = o as AbstractReturnType;
+			if (rt == null) return false;
+			return this.fullyQualifiedName == rt.fullyQualifiedName;
+		}
+		
+		public override int GetHashCode()
+		{
+			return fullyQualifiedName.GetHashCode();
+		}
+		
 		string fullyQualifiedName = null;
 		
 		public virtual string FullyQualifiedName {
@@ -59,9 +71,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public int[] ArrayDimensions {
+		public int ArrayDimensions {
 			get {
-				return null;
+				return 0;
 			}
 		}
 	}

src/Main/Base/Project/Src/Dom/Implementations/ArrayReturnType.cs

@@ -0,0 +1,85 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	public sealed class ArrayReturnType : ProxyReturnType
+	{
+		IReturnType elementType;
+		int dimensions;
+		
+		public ArrayReturnType(IReturnType elementType, int dimensions)
+		{
+			this.elementType = elementType;
+			this.dimensions = dimensions;
+		}
+		
+		public override string FullyQualifiedName {
+			get {
+				return AppendArrayString(elementType.FullyQualifiedName);
+			}
+		}
+		
+		public override string Name {
+			get {
+				return AppendArrayString(elementType.Name);
+			}
+		}
+		
+		public override string DotNetName {
+			get {
+				return AppendArrayString(elementType.DotNetName);
+			}
+		}
+		
+		public override IReturnType BaseType {
+			get {
+				return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array").DefaultReturnType;
+			}
+		}
+		
+		public override List<IIndexer> GetIndexers()
+		{
+			IClass arr = ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array");
+			IReturnType intRT = ProjectContentRegistry.GetMscorlibContent().GetClass("System.Int32").DefaultReturnType;
+			List<IParameter> p = new List<IParameter>();
+			for (int i = 0; i < dimensions; ++i) {
+				p.Add(new DefaultParameter("index", intRT, null));
+			}
+			List<IIndexer> l = new List<IIndexer>();
+			l.Add(new DefaultIndexer(elementType, p, ModifierEnum.Public, null, null, arr));
+			return l;
+		}
+		
+		public override int ArrayDimensions {
+			get {
+				return dimensions;
+			}
+		}
+		
+		string AppendArrayString(string a)
+		{
+			StringBuilder b = new StringBuilder(a, a.Length + 1 + dimensions);
+			b.Append('[');
+			for (int i = 1; i < dimensions; ++i) {
+				b.Append(',');
+			}
+			b.Append(']');
+			return b.ToString();
+		}
+		
+		public override string ToString()
+		{
+			return String.Format("[ArrayReturnType: {0}, dimensions={1}]", elementType, AppendArrayString(""));
+		}
+	}
+}

src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.cs

@@ -7,7 +7,7 @@
 using System;
 using System.Reflection;
 
-namespace ICSharpCode.SharpDevelop.Dom 
+namespace ICSharpCode.SharpDevelop.Dom
 {
 	[Serializable]
 	public class DefaultEvent : AbstractMember, IEvent
@@ -36,6 +36,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override IMember Clone()
+		{
+			return new DefaultEvent(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
+		}
+		
 		protected DefaultEvent(IClass declaringType, string name) : base(declaringType, name)
 		{
 		}
@@ -51,7 +56,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		public virtual int CompareTo(IEvent value) 
+		public virtual int CompareTo(IEvent value)
 		{
 			int cmp;
 			
@@ -64,11 +69,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 					return cmp;
 				}
 			}
-						
+			
 			return Region.CompareTo(value.Region);
 		}
 		
-		int IComparable.CompareTo(object value) 
+		int IComparable.CompareTo(object value)
 		{
 			return CompareTo((IEvent)value);
 		}

src/Main/Base/Project/Src/Dom/Implementations/DefaultField.cs

@@ -29,6 +29,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.Modifiers = m;
 		}
 		
+		public override IMember Clone()
+		{
+			return new DefaultField(ReturnType, Name, Modifiers, Region, DeclaringType);
+		}
+		
 		public virtual int CompareTo(IField field)
 		{
 			int cmp;

src/Main/Base/Project/Src/Dom/Implementations/DefaultIndexer.cs

@@ -24,14 +24,17 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override IMember Clone()
+		{
+			return new DefaultIndexer(ReturnType, DefaultParameter.Clone(this.Parameters), Modifiers, Region, BodyRegion, DeclaringType);
+		}
 		
 		public virtual IRegion BodyRegion {
 			get {
 				return bodyRegion;
 			}
 		}
-
+		
-
 		public IRegion GetterRegion {
 			get {
 				return getterRegion;

src/Main/Base/Project/Src/Dom/Implementations/DefaultMethod.cs

@@ -38,6 +38,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 		List<IParameter> parameters = null;
 		List<ITypeParameter> typeParameters = null;
 		
+		public override IMember Clone()
+		{
+			DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
+			p.parameters = DefaultParameter.Clone(this.Parameters);
+			return p;
+		}
+		
 		public override string DotNetName {
 			get {
 				if (typeParameters == null || typeParameters.Count == 0)

src/Main/Base/Project/Src/Dom/Implementations/DefaultParameter.cs

@@ -29,6 +29,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 			Name = name;
 		}
 		
+		public DefaultParameter(IParameter p)
+		{
+			this.name = p.Name;
+			this.region = p.Region;
+			this.modifier = p.Modifier;
+			this.returnType = p.ReturnType;
+		}
+		
 		public DefaultParameter(string name, IReturnType type, IRegion region) : this(name)
 		{
 			returnType = type;
@@ -114,6 +122,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public static List<IParameter> Clone(List<IParameter> l)
+		{
+			List<IParameter> r = new List<IParameter>(l.Count);
+			for (int i = 0; i < l.Count; ++i) {
+				r.Add(new DefaultParameter(l[i]));
+			}
+			return r;
+		}
+		
 		public virtual int CompareTo(IParameter value) {
 			int cmp;
 			

src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.cs

@@ -33,8 +33,14 @@ namespace ICSharpCode.SharpDevelop.Dom {
 				return bodyRegion;
 			}
 		}
-
+		
-
+		public override IMember Clone()
+		{
+			DefaultProperty p = new DefaultProperty(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
+			p.parameters = DefaultParameter.Clone(this.Parameters);
+			return p;
+		}
+		
 		public virtual List<IParameter> Parameters {
 			get {
 				if (parameters == null) {

src/Main/Base/Project/Src/Dom/Implementations/DefaultReturnType.cs

@@ -77,7 +77,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return c.Name;
 			}
 		}
-
+		
 		public override string Namespace {
 			get {
 				return c.Namespace;

src/Main/Base/Project/Src/Dom/Implementations/DefaultTypeParameter.cs

@@ -66,5 +66,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			this.name = type.Name;
 		}
+		
+		public override string ToString()
+		{
+			return String.Format("[{0}: {1}]", GetType().Name, name);
+		}
 	}
 }

src/Main/Base/Project/Src/Dom/Implementations/GenericReturnType.cs

@@ -0,0 +1,85 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// GenericReturnType is a reference to a type parameter.
+	/// </summary>
+	public sealed class GenericReturnType : ProxyReturnType
+	{
+		ITypeParameter typeParameter;
+		
+		public ITypeParameter TypeParameter {
+			get {
+				return typeParameter;
+			}
+		}
+		
+		public override bool Equals(object o)
+		{
+			GenericReturnType rt = o as GenericReturnType;
+			if (rt == null) return false;
+			return typeParameter.Equals(rt.typeParameter);
+		}
+		
+		public override int GetHashCode()
+		{
+			return typeParameter.GetHashCode();
+		}
+		
+		public GenericReturnType(ITypeParameter typeParameter)
+		{
+			if (typeParameter == null)
+				throw new ArgumentNullException("typeParameter");
+			this.typeParameter = typeParameter;
+		}
+		
+		public override string FullyQualifiedName {
+			get {
+				return typeParameter.Name;
+			}
+		}
+		
+		public override string Name {
+			get {
+				return typeParameter.Name;
+			}
+		}
+		
+		public override string Namespace {
+			get {
+				return "";
+			}
+		}
+		
+		public override string DotNetName {
+			get {
+				if (typeParameter.Method != null)
+					return "``" + typeParameter.Index;
+				else
+					return "`" + typeParameter.Index;
+			}
+		}
+		
+		public override IReturnType BaseType {
+			get {
+				return null;
+				// return typeParameter.Constraint;
+			}
+		}
+		
+		public override string ToString()
+		{
+			return String.Format("[GenericReturnType: {0}]", typeParameter);
+		}
+	}
+}

src/Main/Base/Project/Src/Dom/Implementations/LazyReturnType.cs

@@ -38,6 +38,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.data = data;
 		}
 		
+		public override bool Equals(object o)
+		{
+			LazyReturnType rt = o as LazyReturnType;
+			if (rt == null) return false;
+			if (!context.Equals(rt.context)) return false;
+			return data.Equals(rt.data);
+		}
+		
+		public override int GetHashCode()
+		{
+			return context.GetHashCode() ^ data.GetHashCode();
+		}
+		
 		public override IReturnType BaseType {
 			get {
 				return context.Resolve(data);
@@ -66,6 +79,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 			IClass c = content.GetClass((string)data);
 			return (c != null) ? c.DefaultReturnType : null;
 		}
+		
+		public override bool Equals(object obj)
+		{
+			GetClassResolveContext b = obj as GetClassResolveContext;
+			if (b == null) return false;
+			return content == b.content;
+		}
+		
+		public override int GetHashCode()
+		{
+			return content.GetHashCode();
+		}
 	}
 	
 	public class SearchClassResolveContext : IResolveContext
@@ -86,5 +111,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 			IClass c = declaringClass.ProjectContent.SearchType((string)data, declaringClass, caretLine, caretColumn);
 			return (c != null) ? c.DefaultReturnType : null;
 		}
+		
+		public override bool Equals(object obj)
+		{
+			SearchClassResolveContext b = obj as SearchClassResolveContext;
+			if (b == null) return false;
+			if (declaringClass != b.declaringClass) return false;
+			if (caretLine != b.caretLine) return false;
+			if (caretColumn != b.caretColumn) return false;
+			return true;
+		}
+		
+		public override int GetHashCode()
+		{
+			return declaringClass.GetHashCode() ^ caretLine ^ caretColumn;
+		}
 	}
 }

src/Main/Base/Project/Src/Dom/Implementations/ProxyReturnType.cs

@@ -49,38 +49,38 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// Gets the array ranks of the return type.
 		/// When the return type is not an array, this property returns null.
 		/// </summary>
-		public virtual int[] ArrayDimensions {
+		public virtual int ArrayDimensions {
 			get {
 				IReturnType baseType = BaseType;
-				return (baseType != null) ? baseType.ArrayDimensions : null;
+				return (baseType != null) ? baseType.ArrayDimensions : 0;
 			}
 		}
 		
-		public List<IMethod> GetMethods()
+		public virtual List<IMethod> GetMethods()
 		{
 			IReturnType baseType = BaseType;
 			return (baseType != null) ? baseType.GetMethods() : new List<IMethod>();
 		}
 		
-		public List<IProperty> GetProperties()
+		public virtual List<IProperty> GetProperties()
 		{
 			IReturnType baseType = BaseType;
 			return (baseType != null) ? baseType.GetProperties() : new List<IProperty>();
 		}
 		
-		public List<IField> GetFields()
+		public virtual List<IField> GetFields()
 		{
 			IReturnType baseType = BaseType;
 			return (baseType != null) ? baseType.GetFields() : new List<IField>();
 		}
 		
-		public List<IEvent> GetEvents()
+		public virtual List<IEvent> GetEvents()
 		{
 			IReturnType baseType = BaseType;
 			return (baseType != null) ? baseType.GetEvents() : new List<IEvent>();
 		}
 		
-		public List<IIndexer> GetIndexers()
+		public virtual List<IIndexer> GetIndexers()
 		{
 			IReturnType baseType = BaseType;
 			return (baseType != null) ? baseType.GetIndexers() : new List<IIndexer>();

src/Main/Base/Project/Src/Dom/Implementations/SpecificReturnType.cs

@@ -0,0 +1,137 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// SpecificReturnType is a reference to class where the type parameters are specified.
+	/// Example: List&lt;string&gt;
+	/// </summary>
+	public sealed class SpecificReturnType : ProxyReturnType
+	{
+		List<IReturnType> typeParameters;
+		IReturnType baseType;
+		
+		public SpecificReturnType(IReturnType baseType, List<IReturnType> typeParameters)
+		{
+			if (baseType == null)
+				throw new ArgumentNullException("baseType");
+			if (typeParameters == null)
+				throw new ArgumentNullException("typeParameter");
+			this.typeParameters = typeParameters;
+			this.baseType = baseType;
+		}
+		
+		public override bool Equals(object o)
+		{
+			SpecificReturnType rt = o as SpecificReturnType;
+			if (rt == null) return false;
+			if (!baseType.Equals(rt.baseType)) return false;
+			if (typeParameters.Count != rt.typeParameters.Count) return false;
+			for (int i = 0; i < typeParameters.Count; ++i) {
+				if (!typeParameters[i].Equals(rt.typeParameters[i])) return false;
+			}
+			return true;
+		}
+		
+		public override int GetHashCode()
+		{
+			int code = baseType.GetHashCode();
+			foreach (IReturnType t in typeParameters) {
+				code ^= t.GetHashCode();
+			}
+			return code;
+		}
+		
+		public override IReturnType BaseType {
+			get {
+				return baseType;
+			}
+		}
+		
+		bool CheckReturnType(IReturnType t)
+		{
+			GenericReturnType rt = t as GenericReturnType;
+			if (rt == null) return false;
+			return rt.TypeParameter.Method == null;
+		}
+		
+		bool CheckParameters(List<IParameter> l)
+		{
+			foreach (IParameter p in l) {
+				if (CheckReturnType(p.ReturnType)) return true;
+			}
+			return false;
+		}
+		
+		IReturnType TranslateType(IReturnType input)
+		{
+			GenericReturnType rt = input as GenericReturnType;
+			if (rt == null) return input;
+			if (rt.TypeParameter.Method != null) return input;
+			if (rt.TypeParameter.Index >= typeParameters.Count) return input;
+			return typeParameters[rt.TypeParameter.Index];
+		}
+		
+		public override List<IMethod> GetMethods()
+		{
+			List<IMethod> l = baseType.GetMethods();
+			for (int i = 0; i < l.Count; ++i) {
+				if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters)) {
+					l[i] = (IMethod)l[i].Clone();
+					l[i].ReturnType = TranslateType(l[i].ReturnType);
+					for (int j = 0; j < l[i].Parameters.Count; ++j) {
+						l[i].Parameters[j].ReturnType = TranslateType(l[i].Parameters[j].ReturnType);
+					}
+				}
+			}
+			return l;
+		}
+		
+		public override List<IProperty> GetProperties()
+		{
+			List<IProperty> l = baseType.GetProperties();
+			return l;
+		}
+		
+		public override List<IField> GetFields()
+		{
+			List<IField> l = baseType.GetFields();
+			return l;
+		}
+		
+		public override List<IEvent> GetEvents()
+		{
+			List<IEvent> l = baseType.GetEvents();
+			return l;
+		}
+		
+		public override List<IIndexer> GetIndexers()
+		{
+			List<IIndexer> l = baseType.GetIndexers();
+			for (int i = 0; i < l.Count; ++i) {
+				if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters)) {
+					l[i] = (IIndexer)l[i].Clone();
+					l[i].ReturnType = TranslateType(l[i].ReturnType);
+					for (int j = 0; j < l[i].Parameters.Count; ++j) {
+						l[i].Parameters[j].ReturnType = TranslateType(l[i].Parameters[j].ReturnType);
+					}
+				}
+			}
+			return l;
+		}
+		
+		public override string ToString()
+		{
+			return String.Format("[SpecificReturnType: {0}<{1}>]", baseType, typeParameters);
+		}
+	}
+}

src/Main/Base/Project/Src/Dom/NRefactoryResolver/NRefactoryResolver.cs

@@ -58,6 +58,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 		}
 		
+		public int CaretLine {
+			get {
+				return caretLine;
+			}
+		}
+		
+		public int CaretColumn {
+			get {
+				return caretColumn;
+			}
+		}
+		
 		public NRefactoryResolver(SupportedLanguages language)
 		{
 			this.language = language;
@@ -550,13 +562,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (v == null) {
 				return null;
 			}
-			IClass c = SearchType(v.TypeRef.SystemType, callingClass, cu);
+			return TypeVisitor.CreateReturnType(v.TypeRef, this);
-			if (c != null) {
-				return c.DefaultReturnType;
-			} else {
-				//return new ReturnType(v.TypeRef);
-				return null;
-			}
 		}
 		
 		LocalLookupVariable SearchVariable(string name)

src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 
 using ICSharpCode.NRefactory.Parser;
 using ICSharpCode.NRefactory.Parser.AST;
@@ -23,7 +24,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		public override object Visit(PrimitiveExpression primitiveExpression, object data)
 		{
 			if (primitiveExpression.Value != null) {
-				return ReflectionReturnType(primitiveExpression.Value.GetType());
+				return CreateReturnType(primitiveExpression.Value.GetType());
 			}
 			return null;
 		}
@@ -141,7 +142,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				if (name != null) {
 					string n = resolver.SearchNamespace(name + "." + fieldReferenceExpression.FieldName, null);
 					if (n != null) {
-						return NamespaceReturnType(n);
+						return CreateNamespaceReturnType(n);
 					}
 					IClass c = resolver.SearchType(name + "." + fieldReferenceExpression.FieldName, resolver.CallingClass, resolver.CompilationUnit);
 					if (c != null) {
@@ -178,11 +179,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 			string name = resolver.SearchNamespace(identifierExpression.Identifier, resolver.CompilationUnit);
 			if (name != null && name != "") {
-				return NamespaceReturnType(name);
+				return CreateNamespaceReturnType(name);
 			}
 			IClass c = resolver.SearchType(identifierExpression.Identifier, resolver.CallingClass, resolver.CompilationUnit);
 			if (c != null) {
-				return c.DefaultReturnType;;
+				return c.DefaultReturnType;
 			}
 			return resolver.DynamicLookup(identifierExpression.Identifier);
 		}
@@ -234,12 +235,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public override object Visit(SizeOfExpression sizeOfExpression, object data)
 		{
-			return ReflectionReturnType(typeof(int));
+			return CreateReturnType(typeof(int));
 		}
 		
 		public override object Visit(TypeOfExpression typeOfExpression, object data)
 		{
-			return ReflectionReturnType(typeof(Type));
+			return CreateReturnType(typeof(Type));
 		}
 		
 		public override object Visit(CheckedExpression checkedExpression, object data)
@@ -365,17 +366,38 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(TypeReference reference)
 		{
-			return null;
+			return CreateReturnType(reference, resolver);
 		}
 		
-		IReturnType NamespaceReturnType(string namespaceName)
+		public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
 		{
-			return null;
+			if (reference.IsNull) return null;
+			IResolveContext context = new SearchClassResolveContext(resolver.CallingClass, resolver.CaretLine, resolver.CaretColumn);
+			IReturnType t = new LazyReturnType(context, reference.SystemType);
+			if (reference.GenericTypes.Count > 0) {
+				List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count);
+				for (int i = 0; i < reference.GenericTypes.Count; ++i) {
+					para.Add(CreateReturnType(reference.GenericTypes[i], resolver));
+				}
+				t = new SpecificReturnType(t, para);
+			}
+			if (reference.IsArrayType) {
+				for (int i = 0; i < reference.RankSpecifier.Length; ++i) {
+					t = new ArrayReturnType(t, reference.RankSpecifier[i]);
+				}
+			}
+			return t;
 		}
 		
-		IReturnType ReflectionReturnType(Type t)
+		IReturnType CreateNamespaceReturnType(string namespaceName)
 		{
 			return null;
 		}
+		
+		IReturnType CreateReturnType(Type type)
+		{
+			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(),
+			                                   type);
+		}
 	}
 }

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionIndexer.cs

@@ -30,7 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IParameter> parameters = new List<IParameter>();
 				foreach (ParameterInfo parameterInfo in propertyInfo.GetIndexParameters()) {
-					parameters.Add(new ReflectionParameter(parameterInfo, DeclaringType.ProjectContent));
+					parameters.Add(new ReflectionParameter(parameterInfo, this));
 				}
 				return parameters;
 			}

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionMethod.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				List<IParameter> parameters = new List<IParameter>();
 				foreach (ParameterInfo paramInfo in methodBase.GetParameters()) {
-					parameters.Add(new ReflectionParameter(paramInfo, DeclaringType.ProjectContent));
+					parameters.Add(new ReflectionParameter(paramInfo, this));
 				}
 				return parameters;
 			}

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionParameter.cs

@@ -15,20 +15,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 	public class ReflectionParameter : DefaultParameter
 	{
 		ParameterInfo parameterInfo;
-		IProjectContent content;
+		IMember member;
 		
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(content, parameterInfo.ParameterType);
+				return ReflectionReturnType.Create(member, parameterInfo.ParameterType);
 			}
 			set {
 			}
 		}
 		
-		public ReflectionParameter(ParameterInfo parameterInfo, IProjectContent content) : base(parameterInfo.Name)
+		public ReflectionParameter(ParameterInfo parameterInfo, IMember member) : base(parameterInfo.Name)
 		{
 			this.parameterInfo = parameterInfo;
-			this.content = content;
+			this.member = member;
 			
 			if (parameterInfo.IsOut) {
 				modifier |= ParameterModifier.Out;

src/Main/Base/Project/Src/Dom/ReflectionLayer/ReflectionReturnType.cs

@@ -15,17 +15,30 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public static IReturnType Create(IProjectContent content, Type type)
 		{
 			string name = type.FullName;
-			if (name == null) {
+			if (name == null)
-				// this could be a generic type
 				return null;
+			if (type.IsArray) {
+				return MakeArray(type, Create(content, type.GetElementType()));
+			} else {
+				return new LazyReturnType(new GetClassResolveContext(content), name);
 			}
-			return new LazyReturnType(new GetClassResolveContext(content), name);
 		}
 		
 		public static IReturnType Create(IMember member, Type type)
 		{
+			if (type.IsArray) {
+				return MakeArray(type, Create(member, type.GetElementType()));
+			} else if (type.IsGenericParameter) {
+				IClass c = member.DeclaringType;
+				return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]);
+			}
 			return Create(member.DeclaringType.ProjectContent, type);
 		}
+		
+		static IReturnType MakeArray(Type type, IReturnType baseType)
+		{
+			return new ArrayReturnType(baseType, type.GetArrayRank());
+		}
 	}
 	
 	/*
@@ -74,5 +87,5 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 	}
-	*/
+	 */
 }

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

@@ -60,36 +60,13 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		
 		public string Description {
 			get {
-				// get correct delegate description (when description is requested)
-				// in the classproxies aren't methods saved, therefore delegate methods
-				// must be get through the real class instead out of the proxy
-				//
-				// Mike
-//		TODO: Still useful ?
-//				if (c is ClassProxy && c.ClassType == ClassType.Delegate) {
-//					description = ambience.Convert(ParserService.GetClass(c.FullyQualifiedName));
-//					c = null;
-//				}
-				if (documentation == null) {
-					return "";
-				}
 				// don't give a description string, if no documentation or description is provided
-				if (description.Length + documentation.Length == 0) {
+				if (description.Length == 0 && (documentation == null || documentation.Length == 0)) {
 					return "";
 				}
-				if (!convertedDocumentation) {
+				if (!convertedDocumentation && documentation != null) {
 					convertedDocumentation = true;
-					try {
+					documentation = GetDocumentation(documentation);
-						documentation = GetDocumentation(documentation);
-						// new (by G.B.)
-						// XmlDocument doc = new XmlDocument();
-						// doc.LoadXml("<doc>" + documentation + "</doc>");
-						// XmlNode root      = doc.DocumentElement;
-						// XmlNode paramDocu = root.SelectSingleNode("summary");
-						// documentation = paramDocu.InnerXml;
-					} catch (Exception e) {
-						Console.WriteLine(e.ToString());
-					}
 				}
 				
 				return description + (overloads > 0 ? " " + StringParser.Parse("${res:ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.CodeCompletionData.OverloadsCounter}", new string[,] {{"NumOverloads", overloads.ToString()}}) : String.Empty) + "\n" + documentation;