Implemented code completion for generics. Fixed code completion for arrays.

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

src/AddIns/BackendBindings/CSharpBinding/Project/Src/CSharpAmbience.cs

@@ -156,7 +156,7 @@ namespace ICSharpCode.Core
 				}
 				builder.Append(' ');
 			}
-			if (c.ClassType == ClassType.Delegate && c.Methods.Count > 0) {
+			if (ShowReturnType && c.ClassType == ClassType.Delegate) {
 				foreach(IMethod m in c.Methods) {
 					if (m.Name != "Invoke") continue;
 					
@@ -187,7 +187,7 @@ namespace ICSharpCode.Core
 				builder.Append('>');
 			}
 			
-			if (c.ClassType == ClassType.Delegate) {
+			if (ShowReturnType && c.ClassType == ClassType.Delegate) {
 				builder.Append(" (");
 				if (IncludeHTMLMarkup) builder.Append("<br>");
 				
@@ -534,19 +534,15 @@ namespace ICSharpCode.Core
 				builder.Append("</a>");
 			}
 			
-			/*
+			if (returnType is SpecificReturnType) {
-			for (int i = 0; i < returnType.PointerNestingLevel; ++i) {
+				SpecificReturnType rt = (SpecificReturnType)returnType;
-				builder.Append('*');
+				builder.Append('<');
-			}
+				for (int i = 0; i < rt.TypeParameters.Count; ++i) {
-			
+					if (i > 0) builder.Append(", ");
-			for (int i = 0; i < returnType.ArrayCount; ++i) {
+					builder.Append(Convert(rt.TypeParameters[i]));
-				builder.Append('[');
-				for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) {
-					builder.Append(',');
 				}
-				builder.Append(']');
+				builder.Append('>');
 			}
-			*/
 			
 			return builder.ToString();
 		}

src/AddIns/BackendBindings/VBNetBinding/Project/Src/VBNetAmbience.cs

@@ -504,19 +504,15 @@ namespace VBNetBinding
 				builder.Append("</a>");
 			}
 			
-			/*
+			if (returnType is SpecificReturnType) {
-			for (int i = 0; i < returnType.PointerNestingLevel; ++i) {
+				SpecificReturnType rt = (SpecificReturnType)returnType;
-				builder.Append('*');
+				builder.Append("(Of");
-			}
+				for (int i = 0; i < rt.TypeParameters.Count; ++i) {
-			
+					if (i > 0) builder.Append(", ");
-			for (int i = 0; i < returnType.ArrayCount; ++i) {
+					builder.Append(Convert(rt.TypeParameters[i]));
-				builder.Append('(');
-				for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) {
-					builder.Append(',');
 				}
 				builder.Append(')');
 			}
-			*/
 			
 			return builder.ToString();
 		}

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

@@ -19,10 +19,20 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public ArrayReturnType(IReturnType elementType, int dimensions)
 		{
+			if (dimensions <= 0)
+				throw new ArgumentOutOfRangeException("dimensions", dimensions, "dimensions must be positive");
+			if (elementType == null)
+				throw new ArgumentNullException("elementType");
 			this.elementType = elementType;
 			this.dimensions = dimensions;
 		}
 		
+		public IReturnType ElementType {
+			get {
+				return elementType;
+			}
+		}
+		
 		public override string FullyQualifiedName {
 			get {
 				return AppendArrayString(elementType.FullyQualifiedName);

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

@@ -42,6 +42,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			DefaultMethod p = new DefaultMethod(Name, ReturnType, Modifiers, Region, BodyRegion, DeclaringType);
 			p.parameters = DefaultParameter.Clone(this.Parameters);
+			p.documentationTag = DocumentationTag;
 			return p;
 		}
 		
@@ -54,8 +55,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		string documentationTag;
+		
 		public override string DocumentationTag {
 			get {
+				if (documentationTag == null) {
 					string dotnetName = this.DotNetName;
 					StringBuilder b = new StringBuilder("M:", dotnetName.Length + 2);
 					b.Append(dotnetName);
@@ -70,7 +74,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 						}
 						b.Append(')');
 					}
-				return b.ToString();
+					documentationTag = b.ToString();
+				}
+				return documentationTag;
 			}
 		}
 		

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

@@ -62,9 +62,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.index = index;
 		}
 		
-		public DefaultTypeParameter(Type type)
+		public DefaultTypeParameter(IClass targetClass, Type type)
 		{
+			this.targetClass = targetClass;
 			this.name = type.Name;
+			this.index = type.GenericParameterPosition;
 		}
 		
 		public override string ToString()

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

@@ -20,6 +20,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 		List<IReturnType> typeParameters;
 		IReturnType baseType;
 		
+		public List<IReturnType> TypeParameters {
+			get {
+				return typeParameters;
+			}
+		}
+		
 		public SpecificReturnType(IReturnType baseType, List<IReturnType> typeParameters)
 		{
 			if (baseType == null)
@@ -59,9 +65,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		bool CheckReturnType(IReturnType t)
 		{
-			GenericReturnType rt = t as GenericReturnType;
+			if (t is GenericReturnType) {
-			if (rt == null) return false;
+				GenericReturnType rt = (GenericReturnType)t;
 				return rt.TypeParameter.Method == null;
+			} else if (t is ArrayReturnType) {
+				return CheckReturnType(((ArrayReturnType)t).ElementType);
+			} else {
+				return false;
+			}
 		}
 		
 		bool CheckParameters(List<IParameter> l)
@@ -74,12 +85,21 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		IReturnType TranslateType(IReturnType input)
 		{
-			GenericReturnType rt = input as GenericReturnType;
+			if (input is GenericReturnType) {
-			if (rt == null) return input;
+				GenericReturnType rt = (GenericReturnType)input;
-			if (rt.TypeParameter.Method != null) return input;
+				if (rt.TypeParameter.Method == null) {
-			if (rt.TypeParameter.Index >= typeParameters.Count) return input;
+					if (rt.TypeParameter.Index < typeParameters.Count) {
 						return typeParameters[rt.TypeParameter.Index];
 					}
+				}
+			} else if (input is ArrayReturnType) {
+				IReturnType e = ((ArrayReturnType)input).ElementType;
+				IReturnType t = TranslateType(e);
+				if (e != t)
+					return new ArrayReturnType(t, input.ArrayDimensions);
+			}
+			return input;
+		}
 		
 		public override List<IMethod> GetMethods()
 		{
@@ -99,18 +119,39 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public override List<IProperty> GetProperties()
 		{
 			List<IProperty> l = baseType.GetProperties();
+			for (int i = 0; i < l.Count; ++i) {
+				if (CheckReturnType(l[i].ReturnType) || CheckParameters(l[i].Parameters)) {
+					l[i] = (IProperty)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<IField> GetFields()
 		{
 			List<IField> l = baseType.GetFields();
+			for (int i = 0; i < l.Count; ++i) {
+				if (CheckReturnType(l[i].ReturnType)) {
+					l[i] = (IField)l[i].Clone();
+					l[i].ReturnType = TranslateType(l[i].ReturnType);
+				}
+			}
 			return l;
 		}
 		
 		public override List<IEvent> GetEvents()
 		{
 			List<IEvent> l = baseType.GetEvents();
+			for (int i = 0; i < l.Count; ++i) {
+				if (CheckReturnType(l[i].ReturnType)) {
+					l[i] = (IEvent)l[i].Clone();
+					l[i].ReturnType = TranslateType(l[i].ReturnType);
+				}
+			}
 			return l;
 		}
 		

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

@@ -354,7 +354,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(AST.TypeReference reference)
 		{
-			return null;
+			IClass c = GetCurrentClass();
+			if (c == null) return null;
+			return TypeVisitor.CreateReturnType(reference, c, c.Region.BeginLine + 1, 1);
 		}
 	}
 }

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

@@ -274,7 +274,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				return null;
 			foreach (IMethod method in type.GetMethods()) {
 				if (IsSameName(identifier, method.Name))
-					return new MethodResolveResult(callingClass, callingMember, method.DeclaringType, identifier);
+					return new MethodResolveResult(callingClass, callingMember, type, identifier);
 			}
 			return null;
 		}

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

@@ -268,37 +268,16 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public override object Visit(IndexerExpression indexerExpression, object data)
 		{
-			return null;
-			/*
 			IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, data);
 			if (type == null) {
 				return null;
 			}
-			if (type.ArrayDimensions == null || type.ArrayDimensions.Length == 0) {
+			List<IIndexer> indexers = type.GetIndexers();
-				// check if ther is an indexer
+			if (indexers.Count > 0)
-				if (indexerExpression.TargetObject is ThisReferenceExpression) {
+				return indexers[0].ReturnType;
-					if (resolver.CallingClass == null) {
+			else
-						return null;
-					}
-					type = new ReturnType(resolver.CallingClass.FullyQualifiedName);
-				}
-				ArrayList indexer = resolver.SearchIndexer(type);
-				if (indexer.Count == 0) {
-					return null;
-				}
-				// TODO: get the right indexer
-				return ((IIndexer)indexer[0]).ReturnType;
-			}
-			
-			// TODO: what is a[0] if a is pointer to array or array of pointer ?
-			if (type.ArrayDimensions[type.ArrayDimensions.Length - 1] != indexerExpression.Indices.Count) {
 				return null;
 		}
-			int[] newArray = new int[type.ArrayDimensions.Length - 1];
-			Array.Copy(type.ArrayDimensions, 0, newArray, 0, type.ArrayDimensions.Length - 1);
-			return new ReturnType(type.Name, newArray, type.PointerNestingLevel);
-			 */
-		}
 		
 		public override object Visit(ClassReferenceExpression classReferenceExpression, object data)
 		{
@@ -330,12 +309,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public override object Visit(ObjectCreateExpression objectCreateExpression, object data)
 		{
-			string name = objectCreateExpression.CreateType.Type;
+			return CreateReturnType(objectCreateExpression.CreateType);
-			IClass c = resolver.SearchType(name, resolver.CallingClass, resolver.CompilationUnit);
-			if (c != null)
-				name = c.FullyQualifiedName;
-			return c.DefaultReturnType;
-			//return new ReturnType(name, objectCreateExpression.CreateType.RankSpecifier, objectCreateExpression.CreateType.PointerNestingLevel);
 		}
 		
 		public override object Visit(ArrayCreateExpression arrayCreateExpression, object data)
@@ -372,8 +346,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
 		{
 			if (reference.IsNull) return null;
-			IResolveContext context = new SearchClassResolveContext(resolver.CallingClass, resolver.CaretLine, resolver.CaretColumn);
+			IClass c = resolver.SearchType(reference.SystemType, resolver.CallingClass);
-			IReturnType t = new LazyReturnType(context, reference.SystemType);
+			if (c == null) return null;
+			IReturnType t = c.DefaultReturnType;
 			if (reference.GenericTypes.Count > 0) {
 				List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count);
 				for (int i = 0; i < reference.GenericTypes.Count; ++i) {
@@ -381,9 +356,29 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 				t = new SpecificReturnType(t, para);
 			}
+			return WrapArray(t, reference);
+		}
+		
+		public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, int caretLine, int caretColumn)
+		{
+			if (reference.IsNull) return null;
+			IResolveContext context = new SearchClassResolveContext(callingClass, caretLine, 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], callingClass, caretLine, caretColumn));
+				}
+				t = new SpecificReturnType(t, para);
+			}
+			return WrapArray(t, reference);
+		}
+		
+		static IReturnType WrapArray(IReturnType t, TypeReference reference)
+		{
 			if (reference.IsArrayType) {
 				for (int i = 0; i < reference.RankSpecifier.Length; ++i) {
-					t = new ArrayReturnType(t, reference.RankSpecifier[i]);
+					t = new ArrayReturnType(t, reference.RankSpecifier[i] + 1);
 				}
 			}
 			return t;

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

@@ -155,7 +155,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			if (type.IsGenericTypeDefinition) {
 				foreach (Type g in type.GetGenericArguments()) {
-					this.TypeParameters.Add(new DefaultTypeParameter(g));
+					this.TypeParameters.Add(new DefaultTypeParameter(this, g));
 				}
 			}
 			

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

@@ -30,8 +30,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return MakeArray(type, Create(member, type.GetElementType()));
 			} else if (type.IsGenericParameter) {
 				IClass c = member.DeclaringType;
+				if (type.GenericParameterPosition < c.TypeParameters.Count) {
+					if (c.TypeParameters[type.GenericParameterPosition].Name == type.Name) {
 						return new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]);
 					}
+				}
+				if (type.DeclaringMethod != null) {
+					IMethod method = member as IMethod;
+					if (method != null) {
+						// Create GenericReturnType for generic method
+					}
+				}
+				return new GenericReturnType(new DefaultTypeParameter(c, type));
+			}
 			return Create(member.DeclaringType.ProjectContent, type);
 		}
 		

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

@@ -340,21 +340,22 @@ namespace ICSharpCode.SharpDevelop.Dom
 	/// <example>
 	/// Example expressions:
 	/// "System.Console.WriteLine"
+	/// "a.Add"      (where a is List&lt;string&gt;)
 	/// "SomeMethod" (when SomeMethod is a method in the current class)
 	/// </example>
 	public class MethodResolveResult : ResolveResult
 	{
 		string name;
-		IClass containingClass;
+		IReturnType containingType;
 		
-		public MethodResolveResult(IClass callingClass, IMember callingMember, IClass containingClass, string name)
+		public MethodResolveResult(IClass callingClass, IMember callingMember, IReturnType containingType, string name)
 			: base(callingClass, callingMember, null)
 		{
-			if (containingClass == null)
+			if (containingType == null)
-				throw new ArgumentNullException("containingClass");
+				throw new ArgumentNullException("containingType");
 			if (name == null)
 				throw new ArgumentNullException("name");
-			this.containingClass = containingClass;
+			this.containingType = containingType;
 			this.name = name;
 		}
 		
@@ -368,11 +369,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 		}
 		
 		/// <summary>
-		/// Gets the class on that contains the method.
+		/// Gets the class that contains the method.
 		/// </summary>
-		public IClass ContainingClass {
+		public IReturnType ContainingType {
 			get {
-				return containingClass;
+				return containingType;
 			}
 		}
 	}

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

@@ -257,29 +257,18 @@ namespace ICSharpCode.Core
 //				}
 			}
 			
+			string name = returnType.DotNetName;
 			if (UseFullyQualifiedNames) {
-				builder.Append(returnType.FullyQualifiedName);
+				builder.Append(name);
 			} else {
-				builder.Append(returnType.Name);
+				int pos = returnType.Namespace.Length;
+				builder.Append(name, pos, name.Length - pos);
 			}
 			
 			if (linkSet) {
 				builder.Append("</a>");
 			}
 			
-			// TODO: Re-write this!
-			/*for (int i = 0; i < returnType.PointerNestingLevel; ++i) {
-				builder.Append('*');
-			}
-			
-			for (int i = 0; i < returnType.ArrayCount; ++i) {
-				builder.Append('[');
-				for (int j = 1; j < returnType.ArrayDimensions[i]; ++j) {
-					builder.Append(',');
-				}
-				builder.Append(']');
-			}*/
-			
 			return builder.ToString();
 		}
 		

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/IndexerInsightDataProvider.cs

@@ -71,17 +71,18 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			IReturnType type = result.ResolvedType;
 			if (type == null)
 				return;
+			/*
 			IProjectContent projectContent = ParserService.CurrentProjectContent;
 			if (projectContent == null)
 				return;
 			IClass c = projectContent.GetClass(type.FullyQualifiedName);
 			if (c == null)
 				return;
-			bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);
+			bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);*/
-			foreach (IIndexer i in c.Indexer) {
+			foreach (IIndexer i in type.GetIndexers()) {
-				if (i.IsAccessible(result.CallingClass, canViewProtected)) {
+				//if (i.IsAccessible(result.CallingClass, canViewProtected)) {
 					methods.Add(i);
-				}
+				//}
 			}
 		}
 		

src/Main/Base/Project/Src/TextEditor/Gui/Editor/InsightWindow/MethodInsightDataProvider.cs

@@ -76,33 +76,22 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 				TypeResolveResult result = results as TypeResolveResult;
 				if (result == null)
 					return;
-				IClass c = result.ResolvedClass;
+				foreach (IMethod method in result.ResolvedType.GetMethods()) {
-				bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);
-				foreach (IMethod method in c.Methods) {
 					if (method.IsConstructor) {
-						if (method.IsAccessible(result.CallingClass, canViewProtected)) {
 						methods.Add(method);
 					}
 				}
-				}
 			} else {
 				MethodResolveResult result = results as MethodResolveResult;
 				if (result == null)
 					return;
-				IClass c = result.ContainingClass;
+				foreach (IMethod method in result.ContainingType.GetMethods()) {
-				bool canViewProtected = c.IsTypeInInheritanceTree(result.CallingClass);
-				foreach (IClass curType in c.ClassInheritanceTree) {
-					foreach (IMethod method in curType.Methods) {
 					if (method.Name == result.Name) {
-							if (method.IsAccessible(result.CallingClass, canViewProtected)) {
-								// TODO: exclude methods that were overridden
 						methods.Add(method);
 					}
 				}
 			}
 		}
-			}
-		}
 		
 		public bool CaretOffsetChanged()
 		{