Worked on code completion.

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

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

@@ -26,7 +26,25 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			List<IMethod> l = new List<IMethod>();
 			foreach (IClass bc in c.ClassInheritanceTree) {
-				l.AddRange(bc.Methods);
+				if (bc.ClassType != c.ClassType)
+					continue; // ignore explicit interface implementations
+				
+				// do not add methods that were overridden
+				foreach (IMethod m in bc.Methods) {
+					bool ok = true;
+					foreach (IMethod oldMethod in l) {
+						if (string.Equals(oldMethod.Name, m.Name, StringComparison.InvariantCultureIgnoreCase)) {
+							if (m.IsStatic == oldMethod.IsStatic) {
+								if (DiffUtility.Compare(oldMethod.Parameters, m.Parameters) == 0) {
+									ok = false;
+									break;
+								}
+							}
+						}
+					}
+					if (ok)
+						l.Add(m);
+				}
 			}
 			return l;
 		}
@@ -35,6 +53,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			List<IProperty> l = new List<IProperty>();
 			foreach (IClass bc in c.ClassInheritanceTree) {
+				if (bc.ClassType != c.ClassType)
+					continue; // ignore explicit interface implementations
 				l.AddRange(bc.Properties);
 			}
 			return l;
@@ -44,6 +64,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			List<IField> l = new List<IField>();
 			foreach (IClass bc in c.ClassInheritanceTree) {
+				if (bc.ClassType != c.ClassType)
+					continue; // ignore explicit interface implementations
 				l.AddRange(bc.Fields);
 			}
 			return l;
@@ -53,6 +75,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			List<IEvent> l = new List<IEvent>();
 			foreach (IClass bc in c.ClassInheritanceTree) {
+				if (bc.ClassType != c.ClassType)
+					continue; // ignore explicit interface implementations
 				l.AddRange(bc.Events);
 			}
 			return l;

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

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Text;
 using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.Dom
@@ -70,6 +71,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return rt.TypeParameter.Method == null;
 			} else if (t is ArrayReturnType) {
 				return CheckReturnType(((ArrayReturnType)t).ElementType);
+			} else if (t is SpecificReturnType) {
+				foreach (IReturnType para in ((SpecificReturnType)t).TypeParameters) {
+					if (CheckReturnType(para)) return true;
+				}
+				return false;
 			} else {
 				return false;
 			}
@@ -83,6 +89,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return false;
 		}
 		
+		public override string DotNetName {
+			get {
+				StringBuilder b = new StringBuilder(baseType.DotNetName);
+				b.Append('{');
+				for (int i = 0; i < typeParameters.Count; ++i) {
+					if (i > 0) b.Append(',');
+					b.Append(typeParameters[i].DotNetName);
+				}
+				b.Append('}');
+				return b.ToString();
+			}
+		}
+		
 		IReturnType TranslateType(IReturnType input)
 		{
 			if (input is GenericReturnType) {
@@ -97,6 +116,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 				IReturnType t = TranslateType(e);
 				if (e != t)
 					return new ArrayReturnType(t, input.ArrayDimensions);
+			} else if (input is SpecificReturnType) {
+				SpecificReturnType r = (SpecificReturnType)input;
+				List<IReturnType> para = new List<IReturnType>(r.TypeParameters.Count);
+				for (int i = 0; i < r.TypeParameters.Count; ++i) {
+					para.Add(TranslateType(r.TypeParameters[i]));
+				}
+				return new SpecificReturnType(r.baseType, para);
 			}
 			return input;
 		}

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

@@ -42,8 +42,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		ModifierEnum ConvertModifier(AST.Modifier m, ModifierEnum defaultModifier)
 		{
-			// TODO: Is this possible? I think we have to pay caution to defaultModifier
-			return (ModifierEnum)m;
+			ModifierEnum r = (ModifierEnum)m;
+			if (r == ModifierEnum.None)
+				return defaultModifier;
+			else
+				return r;
 		}
 		
 		public override object Visit(AST.CompilationUnit compilationUnit, object data)
@@ -190,6 +193,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					c.BaseTypes.Add(type);
 				}
 			}
+			int index = 0;
+			foreach (AST.TemplateDefinition template in typeDeclaration.Templates) {
+				c.TypeParameters.Add(new DefaultTypeParameter(c, template.Name, index++));
+			}
 			currentClass.Push(c);
 			object ret = typeDeclaration.AcceptChildren(this, data);
 			currentClass.Pop();
@@ -214,8 +221,29 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 				cu.Classes.Add(c);
 			}
-			DefaultMethod invokeMethod = new DefaultMethod("Invoke", CreateReturnType(delegateDeclaration.ReturnType), ConvertModifier(delegateDeclaration.Modifier), null, null, c);
+			currentClass.Push(c); // necessary for CreateReturnType
+			DefaultMethod invokeMethod = new DefaultMethod("Invoke", CreateReturnType(delegateDeclaration.ReturnType), ModifierEnum.Public, null, null, c);
+			if (delegateDeclaration.Parameters != null) {
+				foreach (AST.ParameterDeclarationExpression par in delegateDeclaration.Parameters) {
+					IReturnType parType = CreateReturnType(par.TypeReference);
+					invokeMethod.Parameters.Add(new DefaultParameter(par.ParameterName, parType, null));
+				}
+			}
 			c.Methods.Add(invokeMethod);
+			invokeMethod = new DefaultMethod("BeginInvoke", CreateReturnType(typeof(IAsyncResult)), ModifierEnum.Public, null, null, c);
+			if (delegateDeclaration.Parameters != null) {
+				foreach (AST.ParameterDeclarationExpression par in delegateDeclaration.Parameters) {
+					IReturnType parType = CreateReturnType(par.TypeReference);
+					invokeMethod.Parameters.Add(new DefaultParameter(par.ParameterName, parType, null));
+				}
+			}
+			invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), null));
+			invokeMethod.Parameters.Add(new DefaultParameter("object", CreateReturnType(typeof(object)), null));
+			c.Methods.Add(invokeMethod);
+			invokeMethod = new DefaultMethod("EndInvoke", CreateReturnType(delegateDeclaration.ReturnType), ModifierEnum.Public, null, null, c);
+			invokeMethod.Parameters.Add(new DefaultParameter("result", CreateReturnType(typeof(IAsyncResult)), null));
+			c.Methods.Add(invokeMethod);
+			currentClass.Pop();
 			return c;
 		}
 		
@@ -358,5 +386,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (c == null) return null;
 			return TypeVisitor.CreateReturnType(reference, c, c.Region.BeginLine + 1, 1);
 		}
+		
+		IReturnType CreateReturnType(Type type)
+		{
+			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type);
+		}
 	}
 }

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

@@ -391,8 +391,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(Type type)
 		{
-			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(),
-			                                   type);
+			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type);
 		}
 	}
 }

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

@@ -5,7 +5,7 @@
 //     <version value="$version"/>
 // </file>
 using System;
-using System.Collections;
+using System.Collections.Generic;
 using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.Dom
@@ -17,6 +17,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 			string name = type.FullName;
 			if (name == null)
 				return null;
+			if (name.Length > 2) {
+				if (name[name.Length - 2] == '`') {
+					name = name.Substring(0, name.Length - 2);
+				}
+			}
 			if (type.IsArray) {
 				return MakeArray(type, Create(content, type.GetElementType()));
 			} else {
@@ -28,6 +33,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			if (type.IsArray) {
 				return MakeArray(type, Create(member, type.GetElementType()));
+			} else if (type.IsGenericType && !type.IsGenericTypeDefinition) {
+				Type[] args = type.GetGenericArguments();
+				List<IReturnType> para = new List<IReturnType>(args.Length);
+				for (int i = 0; i < args.Length; ++i) {
+					para.Add(Create(member, args[i]));
+				}
+				return new SpecificReturnType(Create(member, type.GetGenericTypeDefinition()), para);
 			} else if (type.IsGenericParameter) {
 				IClass c = member.DeclaringType;
 				if (type.GenericParameterPosition < c.TypeParameters.Count) {