Improved code completion.

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

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

@@ -359,6 +359,8 @@ namespace ICSharpCode.Core
 				builder.Append(GetModifier(e));
 			}
 			
+			builder.Append("event ");
+			
 			if (e.ReturnType != null && ShowReturnType) {
 				builder.Append(Convert(e.ReturnType));
 				builder.Append(' ');

src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/ExpressionFinder.cs

@@ -9,7 +9,20 @@ namespace CSharpBinding.Parser
 	/// </summary>
 	public class ExpressionFinder : IExpressionFinder
 	{
-		public string FindExpression(string inText, int offset)
+		ExpressionResult CreateResult(string expression)
+		{
+			if (expression != null && expression.StartsWith("using "))
+				return new ExpressionResult(expression.Substring(6).TrimStart(), ExpressionContext.Namespace, null);
+			else
+				return new ExpressionResult(expression);
+		}
+		
+		public ExpressionResult FindExpression(string inText, int offset)
+		{
+			return CreateResult(FindExpressionInternal(inText, offset));
+		}
+		
+		string FindExpressionInternal(string inText, int offset)
 		{
 			this.text = FilterComments(inText, ref offset);
 			this.offset = this.lastAccept = offset;
@@ -36,11 +49,11 @@ namespace CSharpBinding.Parser
 			return this.text.Substring(this.lastAccept + 1, offset - this.lastAccept);
 		}
 		
-		public string FindFullExpression(string inText, int offset)
+		public ExpressionResult FindFullExpression(string inText, int offset)
 		{
-			string expressionBeforeOffset = FindExpression(inText, offset);
+			string expressionBeforeOffset = FindExpressionInternal(inText, offset);
 			if (expressionBeforeOffset == null || expressionBeforeOffset.Length == 0)
-				return null;
+				return CreateResult(null);
 			StringBuilder b = new StringBuilder(expressionBeforeOffset);
 			// append characters after expression
 			for (int i = offset + 1; i < inText.Length; ++i) {
@@ -68,7 +81,7 @@ namespace CSharpBinding.Parser
 					break;
 				}
 			}
-			return b.ToString();
+			return CreateResult(b.ToString());
 		}
 		
 		int FindEndOfTypeParameters(string inText, int offset)

src/AddIns/BackendBindings/VBNetBinding/Project/Src/Parser/ExpressionFinder.cs

@@ -9,7 +9,20 @@ namespace VBNetBinding.Parser
 	/// </summary>
 	public class ExpressionFinder : IExpressionFinder
 	{
-		public string FindExpression(string inText, int offset)
+		ExpressionResult CreateResult(string expression)
+		{
+			if (expression != null && expression.Substring(0, 8).Equals("Imports ", StringComparison.InvariantCultureIgnoreCase))
+				return new ExpressionResult(expression.Substring(8).TrimStart(), ExpressionContext.Namespace, null);
+			else
+				return new ExpressionResult(expression);
+		}
+		
+		public ExpressionResult FindExpression(string inText, int offset)
+		{
+			return CreateResult(FindExpressionInternal(inText, offset));
+		}
+		
+		string FindExpressionInternal(string inText, int offset)
 		{
 			this.text = FilterComments(inText, ref offset);
 			this.offset = this.lastAccept = offset;
@@ -36,11 +49,11 @@ namespace VBNetBinding.Parser
 			return this.text.Substring(this.lastAccept + 1, offset - this.lastAccept);
 		}
 		
-		public string FindFullExpression(string inText, int offset)
+		public ExpressionResult FindFullExpression(string inText, int offset)
 		{
-			string expressionBeforeOffset = FindExpression(inText, offset);
+			string expressionBeforeOffset = FindExpressionInternal(inText, offset);
 			if (expressionBeforeOffset == null || expressionBeforeOffset.Length == 0)
-				return null;
+				return CreateResult(null);
 			StringBuilder b = new StringBuilder(expressionBeforeOffset);
 			// append characters after expression
 			for (int i = offset + 1; i < inText.Length; ++i) {
@@ -61,7 +74,7 @@ namespace VBNetBinding.Parser
 					break;
 				}
 			}
-			return b.ToString();
+			return CreateResult(b.ToString());
 		}
 		
 		// Like VBNetFormattingStrategy.SearchBracketForward, but operates on a string.

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -363,6 +363,8 @@ namespace VBNetBinding
 				builder.Append(GetModifier(e));
 			}
 			
+			builder.Append("Event ");
+			
 			if (IncludeHTMLMarkup) {
 				builder.Append("<b>");
 			}

src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs

@@ -142,7 +142,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		public void CSharpISTest()
 		{
 			BinaryOperatorExpression boe = (BinaryOperatorExpression)ParseUtilCSharp.ParseExpression("a is b", typeof(BinaryOperatorExpression));
-			Assert.AreEqual(BinaryOperatorType.IS, boe.Op);
+			Assert.AreEqual(BinaryOperatorType.TypeCheck, boe.Op);
 			
 			Assert.IsTrue(boe.Left is IdentifierExpression);
 			Assert.IsTrue(boe.Right is TypeReferenceExpression);
@@ -152,7 +152,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		public void CSharpASTest()
 		{
 			BinaryOperatorExpression boe = (BinaryOperatorExpression)ParseUtilCSharp.ParseExpression("a as b", typeof(BinaryOperatorExpression));
-			Assert.AreEqual(BinaryOperatorType.AS, boe.Op);
+			Assert.AreEqual(BinaryOperatorType.AsCast, boe.Op);
 			
 			Assert.IsTrue(boe.Left is IdentifierExpression);
 			Assert.IsTrue(boe.Right is TypeReferenceExpression);
@@ -298,13 +298,13 @@ namespace ICSharpCode.NRefactory.Tests.AST
 		[Test]
 		public void VBNetISTest()
 		{
-			VBNetTestBinaryOperatorExpressionTest("a is b", BinaryOperatorType.IS);
+			VBNetTestBinaryOperatorExpressionTest("a is b", BinaryOperatorType.ReferenceEquality);
 		}
 		
 		[Test]
 		public void VBNetISNotTest()
 		{
-			VBNetTestBinaryOperatorExpressionTest("a IsNot b", BinaryOperatorType.IsNot);
+			VBNetTestBinaryOperatorExpressionTest("a IsNot b", BinaryOperatorType.ReferenceInequality);
 		}
 		
 		[Test]

src/Main/Base/Project/Src/Commands/ClassMemberMenuBuilder.cs

@@ -58,14 +58,18 @@ namespace ICSharpCode.SharpDevelop.Commands
 			if (member is IField) {
 				string propertyName = AbstractPropertyCodeGenerator.GetPropertyName(member.Name);
 				LanguageProperties language = member.DeclaringType.ProjectContent.Language;
-				bool found = false;
+				IProperty foundProperty = null;
 				foreach (IProperty prop in member.DeclaringType.Properties) {
 					if (language.NameComparer.Equals(propertyName, prop.Name)) {
-						found = true;
+						foundProperty = prop;
 						break;
 					}
 				}
-				if (!found) {
+				if (foundProperty != null) {
+					cmd = new MenuCommand("Go to &property", GotoProperty);
+					cmd.Tag = member;
+					list.Add(cmd);
+				} else {
 					cmd = new MenuCommand("Create &getter", CreateGetter);
 					cmd.Tag = member;
 					list.Add(cmd);
@@ -78,11 +82,38 @@ namespace ICSharpCode.SharpDevelop.Commands
 			return list.ToArray();
 		}
 		
+		TextEditorControl JumpToDefinition(IMember member)
+		{
+			IViewContent viewContent = null;
+			ICompilationUnit cu = member.DeclaringType.CompilationUnit;
+			if (cu != null) {
+				string fileName = cu.FileName;
+				if (fileName != null) {
+					if (member.Region != null && member.Region.BeginLine > 0) {
+						viewContent = FileService.JumpToFilePosition(fileName, member.Region.BeginLine - 1, member.Region.BeginColumn - 1);
+					} else {
+						FileService.OpenFile(fileName);
+					}
+				}
+			}
+			ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.ITextEditorControlProvider tecp = viewContent as ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.ITextEditorControlProvider;
+			return (tecp == null) ? null : tecp.TextEditorControl;
+		}
+		
 		TextEditorControl JumpBehindDefinition(IMember member)
 		{
-			IViewContent viewContent;
-			viewContent = FileService.JumpToFilePosition(member.DeclaringType.CompilationUnit.FileName,
-			                                             member.Region.EndLine, 0);
+			IViewContent viewContent = null;
+			ICompilationUnit cu = member.DeclaringType.CompilationUnit;
+			if (cu != null) {
+				string fileName = cu.FileName;
+				if (fileName != null) {
+					if (member.Region != null && member.Region.EndLine > 0) {
+						viewContent = FileService.JumpToFilePosition(fileName, member.Region.EndLine, 0);
+					} else {
+						FileService.OpenFile(fileName);
+					}
+				}
+			}
 			ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.ITextEditorControlProvider tecp = viewContent as ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor.ITextEditorControlProvider;
 			return (tecp == null) ? null : tecp.TextEditorControl;
 		}
@@ -117,24 +148,27 @@ namespace ICSharpCode.SharpDevelop.Commands
 			generator.GenerateCode(textEditor.ActiveTextAreaControl.TextArea, list);
 		}
 		
+		void GotoProperty(object sender, EventArgs e)
+		{
+			MenuCommand item = (MenuCommand)sender;
+			IMember member = (IMember)item.Tag;
+			string propertyName = AbstractPropertyCodeGenerator.GetPropertyName(member.Name);
+			LanguageProperties language = member.DeclaringType.ProjectContent.Language;
+			foreach (IProperty prop in member.DeclaringType.Properties) {
+				if (language.NameComparer.Equals(propertyName, prop.Name)) {
+					JumpToDefinition(prop);
+					break;
+				}
+			}
+		}
+		
 		void GoToBase(object sender, EventArgs e)
 		{
 			MenuCommand item = (MenuCommand)sender;
 			IMember member = (IMember)item.Tag;
 			IMember baseMember = RefactoringService.FindBaseMember(member);
 			if (baseMember != null) {
-				ICompilationUnit cu = baseMember.DeclaringType.CompilationUnit;
-				if (cu != null) {
-					string fileName = cu.FileName;
-					if (fileName != null) {
-						if (baseMember.Region != null && baseMember.Region.BeginLine > 0) {
-							FileService.JumpToFilePosition(fileName, baseMember.Region.BeginLine - 1, 0);
-						} else {
-							FileService.JumpToFilePosition(fileName, 0, 0);
-						}
-						return;
-					}
-				}
+				JumpToDefinition(baseMember);
 			}
 		}
 		

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

@@ -107,6 +107,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		//IMember SearchMember(string memberName);
 		
+		/// <summary>Return true if the specified class is a base class of this class; otherwise return false.</summary>
+		/// <remarks>Returns false when possibleBaseClass is null.</remarks>
 		bool IsTypeInInheritanceTree(IClass possibleBaseClass);
 		
 		List<IMember> GetAccessibleMembers(IClass callingClass, bool showStatic);

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -14,11 +14,56 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// <summary>
 		/// Finds an expression before the current offset.
 		/// </summary>
-		string FindExpression(string text, int offset);
+		ExpressionResult FindExpression(string text, int offset);
 		
 		/// <summary>
 		/// Finds an expression around the current offset.
 		/// </summary>
-		string FindFullExpression(string text, int offset);
+		ExpressionResult FindFullExpression(string text, int offset);
+	}
+	
+	/// <summary>
+	/// Enumeration for possible contexts in which expressions can be.
+	/// </summary>
+	public enum ExpressionContext
+	{
+		/// <summary>Default/unknown context</summary>
+		Default,
+		/// <summary>Context expects a type name</summary>
+		/// <example>typeof(*expr*), is *expr*, using(*expr* ...)</example>
+		Type,
+		/// <summary>Context expects a type deriving from exception</summary>
+		/// <example>catch(*expr*), throw new *expr*</example>
+		ExceptionType,
+		/// <summary>Context expects a non-abstract type that has accessible constructors</summary>
+		/// <example>new *expr*();</example>
+		ConstructableType,
+		/// <summary>Context expects a namespace name.</summary>
+		/// <example>using *expr*;</example>
+		Namespace,
+	}
+	
+	/// <summary>
+	/// Structure containing the result of a call to an expression finder.
+	/// </summary>
+	public struct ExpressionResult
+	{
+		/// <summary>The expression that has been found at the specified offset.</summary>
+		public string Expression;
+		/// <summary>Specifies the context in which the expression was found.</summary>
+		public ExpressionContext Context;
+		/// <summary>An object carrying additional language-dependend data.</summary>
+		public object Tag;
+		
+		public ExpressionResult(string expression) : this(expression, ExpressionContext.Default, null) {}
+		public ExpressionResult(string expression, ExpressionContext context) : this(expression, context, null) {}
+		public ExpressionResult(string expression, object tag) : this(expression, ExpressionContext.Default, tag)  {}
+		
+		public ExpressionResult(string expression, ExpressionContext context, object tag)
+		{
+			this.Expression = expression;
+			this.Context = context;
+			this.Tag = tag;
+		}
 	}
 }

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

@@ -59,20 +59,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override IReturnType BaseType {
 			get {
-				return ProjectContentRegistry.GetMscorlibContent().GetClass("System.Array").DefaultReturnType;
+				return ReflectionReturnType.Array;
 			}
 		}
 		
 		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));
+				p.Add(new DefaultParameter("index", ReflectionReturnType.Int, null));
 			}
 			List<IIndexer> l = new List<IIndexer>();
-			l.Add(new DefaultIndexer(elementType, p, ModifierEnum.Public, null, null, arr));
+			l.Add(new DefaultIndexer(elementType, p, ModifierEnum.Public, null, null, BaseType.GetUnderlyingClass()));
 			return l;
 		}
 		
@@ -88,6 +86,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		/// <summary>
+		/// Appends the array characters ([,,,]) to the string <paramref name="a"/>.
+		/// </summary>
 		string AppendArrayString(string a)
 		{
 			StringBuilder b = new StringBuilder(a, a.Length + 1 + dimensions);

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

@@ -57,11 +57,16 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public IReturnType DefaultReturnType {
 			get {
 				if (defaultReturnType == null)
-					defaultReturnType = new DefaultReturnType(this);
+					defaultReturnType = CreateDefaultReturnType();
 				return defaultReturnType;
 			}
 		}
 		
+		protected virtual IReturnType CreateDefaultReturnType()
+		{
+			return new DefaultReturnType(this);
+		}
+		
 		public ICompilationUnit CompilationUnit {
 			[System.Diagnostics.DebuggerStepThrough]
 			get {
@@ -285,16 +290,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			if (possibleBaseClass == null) {
 				return false;
 			}
-			
 			if (FullyQualifiedName == possibleBaseClass.FullyQualifiedName) {
 				return true;
 			}
-			
-			foreach (string baseClassName in BaseTypes) {
-				IClass baseClass = ProjectContent.SearchType(baseClassName, this, CompilationUnit, Region != null ? Region.BeginLine : -1, Region != null ? Region.BeginColumn : -1);
-				if (baseClass != null && baseClass.IsTypeInInheritanceTree(possibleBaseClass)) {
+			foreach (IClass baseClass in this.ClassInheritanceTree) {
+				if (possibleBaseClass.FullyQualifiedName == baseClass.FullyQualifiedName)
 					return true;
-				}
 			}
 			return false;
 		}

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

@@ -336,7 +336,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 			}
 			invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), null));
-			invokeMethod.Parameters.Add(new DefaultParameter("object", CreateReturnType(typeof(object)), null));
+			invokeMethod.Parameters.Add(new DefaultParameter("object", ReflectionReturnType.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));
@@ -510,7 +510,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(Type type)
 		{
-			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type);
+			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type, false);
 		}
 	}
 }

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

@@ -152,6 +152,11 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 			}
 			
+			return ResolveInternal(expr);
+		}
+		
+		ResolveResult ResolveInternal(Expression expr)
+		{
 			TypeVisitor typeVisitor = new TypeVisitor(this);
 			IReturnType type;
 			
@@ -159,9 +164,31 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				if (((PrimitiveExpression)expr).Value is int)
 					return null;
 			} else if (expr is InvocationExpression) {
-				IMethod method = typeVisitor.GetMethod((InvocationExpression)expr, null);
-				if (method != null)
+				IMethod method = typeVisitor.GetMethod(expr as InvocationExpression, null);
+				if (method != null) {
 					return CreateMemberResolveResult(method);
+				} else {
+					// InvocationExpression can also be a delegate/event call
+					ResolveResult invocationTarget = ResolveInternal((expr as InvocationExpression).TargetObject);
+					if (invocationTarget == null)
+						return null;
+					type = invocationTarget.ResolvedType;
+					if (type == null)
+						return null;
+					IClass c = type.GetUnderlyingClass();
+					if (c == null || c.ClassType != ClassType.Delegate)
+						return null;
+					// We don't want to show "System.EventHandler.Invoke" in the tooltip
+					// of "EventCall(this, EventArgs.Empty)", we just show the event/delegate for now
+					
+					// but for DelegateCall(params).* completion, we use the delegate's
+					// return type instead of the delegate type itself
+					method = c.Methods.Find(delegate(IMethod innerMethod) { return innerMethod.Name == "Invoke"; });
+					if (method != null)
+						invocationTarget.ResolvedType = method.ReturnType;
+					
+					return invocationTarget;
+				}
 			} else if (expr is FieldReferenceExpression) {
 				FieldReferenceExpression fieldReferenceExpression = (FieldReferenceExpression)expr;
 				if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName == "") {
@@ -520,17 +547,27 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (type == null)
 				return methods;
 			
-			//bool isClassInInheritanceTree = false;
-			//if (callingClass != null)
-			//	isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType);
+			bool isClassInInheritanceTree = false;
+			if (callingClass != null)
+				isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
 			
 			foreach (IMethod m in type.GetMethods()) {
 				if (IsSameName(m.Name, memberName)
-				    // && m.IsAccessible(callingClass, isClassInInheritanceTree)
+				    && m.IsAccessible(callingClass, isClassInInheritanceTree)
 				   ) {
 					methods.Add(m);
 				}
 			}
+//			if (methods.Count == 0) {
+//				foreach (IEvent m in type.GetEvents()) {
+//					if (IsSameName(m.Name, memberName)
+//					    && m.IsAccessible(callingClass, isClassInInheritanceTree)
+//					   ) {
+//						methods.Add(m);
+//						break;
+//					}
+//				}
+//			}
 			return methods;
 		}
 		#endregion
@@ -541,14 +578,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			if (type == null)
 				return null;
-			//bool isClassInInheritanceTree = false;
-			//if (callingClass != null)
-			//	isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(curType);
-			//foreach (IClass c in curType.InnerClasses) {
-			//	if (IsSameName(c.Name, memberName) && c.IsAccessible(callingClass, isClassInInheritanceTree)) {
-			//		return new ReturnType(c.FullyQualifiedName);
-			//	}
-			//}
 			IMember member = GetMember(type, memberName);
 			if (member == null)
 				return null;
@@ -560,9 +589,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			if (type == null)
 				return null;
-			//bool isClassInInheritanceTree = false;
-			//if (callingClass != null)
-			//	isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(c);
+			bool isClassInInheritanceTree = false;
+			if (callingClass != null)
+				isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(type.GetUnderlyingClass());
 			foreach (IProperty p in type.GetProperties()) {
 				if (IsSameName(p.Name, memberName)) {
 					return p;

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

@@ -24,32 +24,61 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		public override object Visit(PrimitiveExpression primitiveExpression, object data)
 		{
 			if (primitiveExpression.Value != null) {
-				return CreateReturnType(primitiveExpression.Value.GetType());
+				return ReflectionReturnType.CreatePrimitive(primitiveExpression.Value.GetType());
 			}
 			return null;
 		}
 		
 		public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
 		{
-			// TODO : Operators
-			return binaryOperatorExpression.Left.AcceptVisitor(this, data);
+			switch (binaryOperatorExpression.Op) {
+				case BinaryOperatorType.AsCast:
+					return binaryOperatorExpression.Right.AcceptVisitor(this, data);
+				case BinaryOperatorType.DivideInteger:
+					return ReflectionReturnType.Int;
+				case BinaryOperatorType.Concat:
+					return ReflectionReturnType.String;
+				case BinaryOperatorType.Equality:
+				case BinaryOperatorType.InEquality:
+				case BinaryOperatorType.ReferenceEquality:
+				case BinaryOperatorType.ReferenceInequality:
+				case BinaryOperatorType.TypeCheck:
+				case BinaryOperatorType.LogicalAnd:
+				case BinaryOperatorType.LogicalOr:
+				case BinaryOperatorType.LessThan:
+				case BinaryOperatorType.LessThanOrEqual:
+				case BinaryOperatorType.GreaterThan:
+				case BinaryOperatorType.GreaterThanOrEqual:
+					return ReflectionReturnType.Bool;
+				default:
+					return binaryOperatorExpression.Left.AcceptVisitor(this, data);
+			}
 		}
 		
 		public override object Visit(ParenthesizedExpression parenthesizedExpression, object data)
 		{
-			if (parenthesizedExpression == null) {
-				return null;
-			}
 			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
 		}
 		
 		public override object Visit(InvocationExpression invocationExpression, object data)
 		{
 			IMethod m = GetMethod(invocationExpression, data);
-			if (m == null)
-				return null;
-			else
+			if (m == null) {
+				// This might also be a delegate invocation:
+				// get the delegate's Invoke method
+				IReturnType targetType = invocationExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
+				if (targetType != null) {
+					IClass c = targetType.GetUnderlyingClass();
+					if (c != null && c.ClassType == ClassType.Delegate) {
+						// find the delegate's return type
+						m = c.Methods.Find(delegate(IMethod innerMethod) { return innerMethod.Name == "Invoke"; });
+					}
+				}
+			}
+			if (m != null)
 				return m.ReturnType;
+			else
+				return null;
 		}
 		
 		public IMethod FindOverload(ArrayList methods, ArrayList arguments, object data)
@@ -114,16 +143,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				InjectMethodTypeParameters(methods, invocationExpression);
 				return FindOverload(methods, invocationExpression.Parameters, data);
 			}
-			// invocationExpression is delegate call
-			IReturnType t = invocationExpression.AcceptChildren(this, data) as IReturnType;
-			if (t == null) {
-				return null;
-			}
-			IClass c = resolver.SearchType(t.FullyQualifiedName, resolver.CallingClass, resolver.CompilationUnit);
-			if (c.ClassType == ClassType.Delegate) {
-				ArrayList methods = resolver.SearchMethod(t, "Invoke");
-				return FindOverload(methods, invocationExpression.Parameters, data);
-			}
 			return null;
 		}
 		
@@ -133,7 +152,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			if (invocationExpression.TypeParameters.Count == 0) return;
 			List<IReturnType> typeParameters = CreateReturnType(invocationExpression.TypeParameters);
 			for (int i = 0; i < methods.Count; ++i) {
-				IMethod m = (IMethod)methods[i];
+				IMethod m = methods[i] as IMethod;
+				if (m == null) continue; // ignore Events
 				if (m.TypeParameters.Count == 0) {
 					m = null; // this is not the correct overload, ignore this method
 				} else {
@@ -362,7 +382,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		List<IReturnType> CreateReturnType(List<TypeReference> references)
 		{
-			return references.ConvertAll<IReturnType>(new Converter<TypeReference, IReturnType>(CreateReturnType));
+			return references.ConvertAll<IReturnType>(CreateReturnType);
 		}
 		
 		IReturnType CreateReturnType(TypeReference reference)
@@ -406,7 +426,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				}
 			}
 			if (t == null) {
-				t = new SearchClassReturnType(callingClass, caretLine, caretColumn, reference.SystemType);
+				if (reference.Type != reference.SystemType) {
+					// keyword-type like void, int, string etc.
+					t = ProjectContentRegistry.GetMscorlibContent().GetClass(reference.SystemType).DefaultReturnType;
+				} else {
+					t = new SearchClassReturnType(callingClass, caretLine, caretColumn, reference.SystemType);
+				}
 			}
 			if (reference.GenericTypes.Count > 0) {
 				List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count);
@@ -460,13 +485,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 		}
 		
-		IReturnType CreateReturnType(Type type)
+		static IReturnType CreateReturnType(Type type)
 		{
-			if (ReflectionReturnType.IsDefaultType(type)) {
-				IClass c = resolver.ProjectContent.GetClass(type.FullName);
-				if (c != null) return c.DefaultReturnType;
-			}
-			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type);
+			return ReflectionReturnType.Create(ProjectContentRegistry.GetMscorlibContent(), type, false);
 		}
 	}
 }

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -124,6 +124,37 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return type.IsSubclassOf(typeof(Delegate)) && type != typeof(MulticastDelegate);
 		}
 		
+		#region VoidClass / VoidReturnType
+		public class VoidClass : ReflectionClass
+		{
+			public VoidClass(ICompilationUnit compilationUnit) : base(compilationUnit, typeof(void), null) {}
+			
+			protected override IReturnType CreateDefaultReturnType() {
+				return new VoidReturnType(this);
+			}
+		}
+		
+		private class VoidReturnType : DefaultReturnType
+		{
+			public VoidReturnType(IClass c) : base(c) {}
+			public override List<IMethod> GetMethods() {
+				return new List<IMethod>(1);
+			}
+			public override List<IProperty> GetProperties() {
+				return new List<IProperty>(1);
+			}
+			public override List<IField> GetFields() {
+				return new List<IField>(1);
+			}
+			public override List<IEvent> GetEvents() {
+				return new List<IEvent>(1);
+			}
+			public override List<IIndexer> GetIndexers() {
+				return new List<IIndexer>(1);
+			}
+		}
+		#endregion
+		
 		public ReflectionClass(ICompilationUnit compilationUnit, Type type, IClass declaringType) : base(compilationUnit, declaringType)
 		{
 			this.type = type;
@@ -135,17 +166,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			
 			// set classtype
-			if (IsDelegate(type)) {
-				this.ClassType = ClassType.Delegate;
-				MethodInfo invoke          = type.GetMethod("Invoke");
-				ReflectionMethod newMethod = new ReflectionMethod(invoke, this);
-				Methods.Add(newMethod);
-			} else if (type.IsInterface) {
+			if (type.IsInterface) {
 				this.ClassType = ClassType.Interface;
 			} else if (type.IsEnum) {
 				this.ClassType = ClassType.Enum;
 			} else if (type.IsValueType) {
 				this.ClassType = ClassType.Struct;
+			} else if (IsDelegate(type)) {
+				this.ClassType = ClassType.Delegate;
 			} else {
 				this.ClassType = ClassType.Class;
 			}
@@ -193,4 +221,5 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 	}
+	
 }

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(this, eventInfo.EventHandlerType);
+				return ReflectionReturnType.Create(this, eventInfo.EventHandlerType, false);
 			}
 			set {
 			}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		FieldInfo fieldInfo;
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(this, fieldInfo.FieldType);
+				return ReflectionReturnType.Create(this, fieldInfo.FieldType, false);
 			}
 			set {
 			}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -20,7 +20,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(this, propertyInfo.PropertyType);
+				return ReflectionReturnType.Create(this, propertyInfo.PropertyType, false);
 			}
 			set {
 			}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -28,7 +28,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public override IReturnType ReturnType {
 			get {
 				if (methodBase is MethodInfo) {
-					return ReflectionReturnType.Create(this, ((MethodInfo)methodBase).ReturnType);
+					return ReflectionReturnType.Create(this, ((MethodInfo)methodBase).ReturnType, false);
 				} else if (methodBase is ConstructorInfo) {
 					return DeclaringType.DefaultReturnType;
 				}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -19,7 +19,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(member, parameterInfo.ParameterType);
+				return ReflectionReturnType.Create(member, parameterInfo.ParameterType, false);
 			}
 			set {
 			}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -18,7 +18,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public override IReturnType ReturnType {
 			get {
-				return ReflectionReturnType.Create(this, propertyInfo.PropertyType);
+				return ReflectionReturnType.Create(this, propertyInfo.PropertyType, false);
 			}
 			set {
 			}

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

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -12,10 +12,87 @@ namespace ICSharpCode.SharpDevelop.Dom
 {
 	public static class ReflectionReturnType
 	{
-		public static IReturnType Create(IProjectContent content, Type type)
+		#region Primitive Types
+		static IReturnType @object, @int, @string, @bool, type, @void, array;
+		
+		/// <summary>Gets a ReturnType describing System.Object.</summary>
+		public static IReturnType Object {
+			get {
+				if (@object == null) {
+					@object = CreatePrimitive(typeof(object));
+				}
+				return @object;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.Int32.</summary>
+		public static IReturnType Int {
+			get {
+				if (@int == null) {
+					@int = CreatePrimitive(typeof(int));
+				}
+				return @int;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.String.</summary>
+		public static IReturnType String {
+			get {
+				if (@string == null) {
+					@string = CreatePrimitive(typeof(string));
+				}
+				return @string;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.Boolean.</summary>
+		public static IReturnType Bool {
+			get {
+				if (@bool == null) {
+					@bool = CreatePrimitive(typeof(bool));
+				}
+				return @bool;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.Type.</summary>
+		public static IReturnType Type {
+			get {
+				if (type == null) {
+					type = CreatePrimitive(typeof(Type));
+				}
+				return type;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.Void.</summary>
+		public static IReturnType Void {
+			get {
+				if (@void == null) {
+					@void = CreatePrimitive(typeof(void));
+				}
+				return @void;
+			}
+		}
+		/// <summary>Gets a ReturnType describing System.Array.</summary>
+		public static IReturnType Array {
+			get {
+				if (array == null) {
+					array = CreatePrimitive(typeof(Array));
+				}
+				return array;
+			}
+		}
+		
+		/// <summary>
+		/// Create a primitive return type.
+		/// Allowed are ONLY simple classes from MsCorlib (no arrays/generics etc.)
+		/// </summary>
+		public static IReturnType CreatePrimitive(Type type)
+		{
+			return ProjectContentRegistry.GetMscorlibContent().GetClass(type.FullName).DefaultReturnType;
+		}
+		#endregion
+		
+		public static IReturnType Create(IProjectContent content, Type type, bool createLazyReturnType)
 		{
 			if (type.IsArray) {
-				return MakeArray(type, Create(content, type.GetElementType()));
+				return MakeArray(type, Create(content, type.GetElementType(), createLazyReturnType));
 			} else {
 				string name = type.FullName;
 				if (name == null)
@@ -28,6 +105,13 @@ namespace ICSharpCode.SharpDevelop.Dom
 				if (name.IndexOf('+') > 0) {
 					name = name.Replace('+', '.');
 				}
+				if (!createLazyReturnType) {
+					IClass c = content.GetClass(name);
+					if (c != null)
+						return c.DefaultReturnType;
+					// example where name is not found: pointers like System.Char*
+					// or when the class is in a assembly that is not referenced
+				}
 				return new GetClassReturnType(content, name);
 			}
 		}
@@ -37,17 +121,17 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return !type.IsArray && !type.IsGenericType && !type.IsGenericParameter;
 		}
 		
-		public static IReturnType Create(IMember member, Type type)
+		public static IReturnType Create(IMember member, Type type, bool createLazyReturnType)
 		{
 			if (type.IsArray) {
-				return MakeArray(type, Create(member, type.GetElementType()));
+				return MakeArray(type, Create(member, type.GetElementType(), createLazyReturnType));
 			} 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]));
+					para.Add(Create(member, args[i], createLazyReturnType));
 				}
-				return new SpecificReturnType(Create(member, type.GetGenericTypeDefinition()), para);
+				return new SpecificReturnType(Create(member, type.GetGenericTypeDefinition(), createLazyReturnType), para);
 			} else if (type.IsGenericParameter) {
 				IClass c = member.DeclaringType;
 				if (type.GenericParameterPosition < c.TypeParameters.Count) {
@@ -63,7 +147,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 				return new GenericReturnType(new DefaultTypeParameter(c, type));
 			}
-			return Create(member.DeclaringType.ProjectContent, type);
+			return Create(member.DeclaringType.ProjectContent, type, createLazyReturnType);
 		}
 		
 		static IReturnType MakeArray(Type type, IReturnType baseType)
@@ -71,52 +155,4 @@ namespace ICSharpCode.SharpDevelop.Dom
 			return new ArrayReturnType(baseType, type.GetArrayRank());
 		}
 	}
-	
-	/*
-	[Serializable]
-	public class ReflectionReturnType : AbstractReturnType
-	{
-		public ReflectionReturnType(Type type)
-		{
-			string fullyQualifiedName = type.FullName == null ? type.Name : type.FullName.Replace("+", ".").Trim('&');
-			
-			// base.FullyQualifiedName = fullyQualifiedName.TrimEnd('[', ']', ',', '*');
-			for (int i = fullyQualifiedName.Length; i > 0; i--) {
-				char c = fullyQualifiedName[i - 1];
-				if (c != '[' && c != ']' && c != ',' && c != '*') {
-					if (i < fullyQualifiedName.Length)
-						fullyQualifiedName = fullyQualifiedName.Substring(0, i);
-					break;
-				}
-			}
-			base.FullyQualifiedName = fullyQualifiedName;
-
-			SetPointerNestingLevel(type);
-			SetArrayDimensions(type);
-			if (arrays == null)
-				arrayDimensions = new int[0];
-			else
-				arrayDimensions = (int[])arrays.ToArray(typeof(int));
-		}
-		
-		ArrayList arrays = null;
-		void SetArrayDimensions(Type type)
-		{
-			if (type.IsArray && type != typeof(Array)) {
-				if (arrays == null)
-					arrays = new ArrayList();
-				arrays.Add(type.GetArrayRank());
-				SetArrayDimensions(type.GetElementType());
-			}
-		}
-		
-		void SetPointerNestingLevel(Type type)
-		{
-			if (type.IsPointer) {
-				SetPointerNestingLevel(type.GetElementType());
-				++pointerNestingLevel;
-			}
-		}
-	}
-	 */
 }

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

@@ -1,7 +1,7 @@
 // <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
-//     <owner name="Mike Krueger" email="mike@icsharpcode.net"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
 //     <version value="$version"/>
 // </file>
 
@@ -69,6 +69,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				return resolvedType;
 			}
+			set {
+				resolvedType = value;
+			}
 		}
 		
 		public virtual ArrayList GetCompletionData(IProjectContent projectContent)
@@ -80,20 +83,23 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			if (resolvedType == null) return null;
 			ArrayList res = new ArrayList();
+			bool isClassInInheritanceTree = false;
+			if (callingClass != null)
+				isClassInInheritanceTree = callingClass.IsTypeInInheritanceTree(resolvedType.GetUnderlyingClass());
 			foreach (IMethod m in resolvedType.GetMethods()) {
-				if (language.ShowMember(m, showStatic))
+				if (language.ShowMember(m, showStatic) && m.IsAccessible(callingClass, isClassInInheritanceTree))
 					res.Add(m);
 			}
 			foreach (IEvent e in resolvedType.GetEvents()) {
-				if (language.ShowMember(e, showStatic))
+				if (language.ShowMember(e, showStatic) && e.IsAccessible(callingClass, isClassInInheritanceTree))
 					res.Add(e);
 			}
 			foreach (IField f in resolvedType.GetFields()) {
-				if (language.ShowMember(f, showStatic))
+				if (language.ShowMember(f, showStatic) && f.IsAccessible(callingClass, isClassInInheritanceTree))
 					res.Add(f);
 			}
 			foreach (IProperty p in resolvedType.GetProperties()) {
-				if (language.ShowMember(p, showStatic))
+				if (language.ShowMember(p, showStatic) && p.IsAccessible(callingClass, isClassInInheritanceTree))
 					res.Add(p);
 			}
 			return res;

src/Main/Base/Project/Src/Gui/Pads/DefinitionViewPad.cs

@@ -79,7 +79,7 @@ namespace ICSharpCode.SharpDevelop.Gui
 			if (expressionFinder == null) return null;
 			Caret caret = ctl.ActiveTextAreaControl.Caret;
 			string content = (e == null) ? ctl.Text : e.Content;
-			string expr = expressionFinder.FindFullExpression(content, caret.Offset);
+			string expr = expressionFinder.FindFullExpression(content, caret.Offset).Expression;
 			if (expr == null) return null;
 			return ParserService.Resolve(expr, caret.Line, caret.Column, fileName, content);
 		}

src/Main/Base/Project/Src/Services/Debugger/DebuggerService.cs

@@ -549,7 +549,7 @@ namespace ICSharpCode.Core
 						LineSegment seg = doc.GetLineSegment(logicPos.Y);
 						int xPosition = Math.Min(seg.Length - 1, logicPos.X);
 						string textContent = doc.TextContent;
-						string expression = expressionFinder.FindFullExpression(textContent, seg.Offset + xPosition);
+						string expression = expressionFinder.FindFullExpression(textContent, seg.Offset + xPosition).Expression;
 						//Console.WriteLine("MouseMove@" + logicPos + ":" + expression);
 						if (expression != null && expression.Length > 0) {
 							if (expression == oldExpression && oldLine == logicPos.Y) {

src/Main/Base/Project/Src/Services/ParserService/ReflectionProjectContent.cs

@@ -26,6 +26,13 @@ namespace ICSharpCode.Core
 					AddClassToNamespaceListInternal(new ReflectionClass(assemblyCompilationUnit, type, null));
 				}
 			}
+			
+			if (assembly == typeof(void).Assembly) {
+				// Replace void through the special class (ReturnType(void).GetMethods() does not return
+				// the methods of System.Object and System.ValueType)
+				AddClassToNamespaceListInternal(new ReflectionClass.VoidClass(assemblyCompilationUnit));
+			}
+			
 			string fileName = LookupLocalizedXmlDoc(assembly.Location);
 			// Not found -> look in runtime directory.
 			if (fileName == null) {

src/Main/Base/Project/Src/Services/RefactoringService/RefactoringService.cs

@@ -105,7 +105,7 @@ namespace ICSharpCode.Core
 				if (expressionFinder == null) {
 					expressionFinder = ParserService.GetExpressionFinder(fileName);
 				}
-				string expr = expressionFinder.FindFullExpression(fileContent, pos + 1);
+				string expr = expressionFinder.FindFullExpression(fileContent, pos + 1).Expression;
 				if (expr != null) {
 					Point position = GetPosition(fileContent, pos);
 					ResolveResult rr = ParserService.Resolve(expr, position.Y, position.X, fileName, fileContent);

src/Main/Base/Project/Src/TextEditor/Actions.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -54,7 +54,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Actions
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(textEditorControl.FileName);
 			if (expressionFinder == null)
 				return;
-			string expression = expressionFinder.FindFullExpression(textContent, textEditorControl.ActiveTextAreaControl.Caret.Offset);
+			string expression = expressionFinder.FindFullExpression(textContent, textEditorControl.ActiveTextAreaControl.Caret.Offset).Expression;
 			if (expression == null || expression.Length == 0)
 				return;
 			ResolveResult result = ParserService.Resolve(expression, caretLineNumber, caretColumn, textEditorControl.FileName, textContent);

src/Main/Base/Project/Src/TextEditor/Commands/CodeGenerators/CodeGenerator.cs

@@ -33,14 +33,14 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 			this.currentClass = currentClass;
 			try {
 				csa = (IAmbience)AddInTree.GetTreeNode("/SharpDevelop/Workbench/Ambiences").BuildChildItem("C#", this);
-				csa.ConversionFlags = ConversionFlags.QualifiedNamesOnlyForReturnTypes | ConversionFlags.ShowReturnType;
+				csa.ConversionFlags = ConversionFlags.ShowAccessibility | ConversionFlags.ShowModifiers | ConversionFlags.QualifiedNamesOnlyForReturnTypes | ConversionFlags.ShowReturnType | ConversionFlags.ShowParameterNames;
 			} catch (Exception) {
 				Console.WriteLine("CSharpAmbience not found -- is the C# backend binding loaded???");
 			}
 			
 			try {
 				vba = (IAmbience)AddInTree.GetTreeNode("/SharpDevelop/Workbench/Ambiences").BuildChildItem("VBNET", this);
-				vba.ConversionFlags = ConversionFlags.QualifiedNamesOnlyForReturnTypes | ConversionFlags.ShowReturnType;
+				vba.ConversionFlags = ConversionFlags.ShowAccessibility | ConversionFlags.ShowModifiers | ConversionFlags.QualifiedNamesOnlyForReturnTypes | ConversionFlags.ShowReturnType | ConversionFlags.ShowParameterNames;
 			} catch (Exception) {
 				Console.WriteLine("VBNet ambience not found -- is the VB.NET backend binding loaded???");
 			}

src/Main/Base/Project/Src/TextEditor/Commands/CodeGenerators/InterfaceImplementorCodeGenerator.cs

@@ -78,7 +78,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 					
 					// search an enqueue all base interfaces
 					foreach (string interfaceName in intf.BaseTypes) {
-					
+						
 						// first look if the interface is in the same namespace
 						IClass baseType = ParserService.CurrentProjectContent.GetClass(intf.Namespace + "." + interfaceName);
 						
@@ -240,8 +240,9 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 			
 			public override string ToString()
 			{
-				
-				return AmbienceService.CurrentAmbience.Convert(c);
+				IAmbience ambience = AmbienceService.CurrentAmbience;
+				ambience.ConversionFlags = ConversionFlags.None;
+				return ambience.Convert(c);
 			}
 		}
 	}

src/Main/Base/Project/Src/TextEditor/Commands/CodeGenerators/OnXXXMethodsCodeGenerator.cs

@@ -98,8 +98,9 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 			
 			public override string ToString()
 			{
-				
-				return AmbienceService.CurrentAmbience.Convert(evt);
+				IAmbience ambience = AmbienceService.CurrentAmbience;
+				ambience.ConversionFlags = ConversionFlags.None;
+				return ambience.Convert(evt);
 			}
 		}
 	}

src/Main/Base/Project/Src/TextEditor/Commands/CodeGenerators/OverrideMethodsCodeGenerator.cs

@@ -113,9 +113,8 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 			
 			public override string ToString()
 			{
-				
 				IAmbience ambience = AmbienceService.CurrentAmbience;
-				ambience.ConversionFlags = ConversionFlags.None;
+				ambience.ConversionFlags = ConversionFlags.ShowParameterNames;
 				return ambience.Convert(method);
 			}
 		}

src/Main/Base/Project/Src/TextEditor/Commands/CodeGenerators/ToStringCodeGenerator.cs

@@ -14,7 +14,7 @@ using ICSharpCode.Core;
 
 namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 {
-	public class ToStringCodeGenerator : CodeGenerator
+	public class ToStringCodeGenerator : AbstractFieldCodeGenerator
 	{
 		public override string CategoryName {
 			get {
@@ -36,9 +36,6 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 		
 		public ToStringCodeGenerator(IClass currentClass) : base(currentClass)
 		{
-			foreach (IField field in currentClass.Fields) {
-				Content.Add(new FieldWrapper(field));
-			}
 		}
 		
 		protected override void StartGeneration(IList items, string fileExtension)
@@ -108,29 +105,5 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Commands
 			++numOps;
 			Return();
 		}
-
-		class FieldWrapper
-		{
-			IField field;
-			
-			public IField Field {
-				get {
-					return field;
-				}
-			}
-			
-			public FieldWrapper(IField field)
-			{
-				this.field = field;
-			}
-			
-			public override string ToString()
-			{
-				
-				IAmbience ambience = AmbienceService.CurrentAmbience;
-				ambience.ConversionFlags = ConversionFlags.None;
-				return ambience.Convert(field);
-			}
-		}
 	}
 }

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

@@ -28,8 +28,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 	/// </summary>
 	public class CodeCompletionDataProvider : ICompletionDataProvider
 	{
-		static
-			Hashtable insertedElements           = new Hashtable();
+		Hashtable insertedElements           = new Hashtable();
 		Hashtable insertedPropertiesElements = new Hashtable();
 		Hashtable insertedEventElements      = new Hashtable();
 		
@@ -51,12 +50,11 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		}
 		ArrayList completionData = null;
 		bool ctrlSpace;
-		bool isNewCompletion;
+		ExpressionContext context;
 		
-		public CodeCompletionDataProvider(bool ctrlSpace, bool isNewCompletion)
+		public CodeCompletionDataProvider(bool ctrlSpace)
 		{
 			this.ctrlSpace = ctrlSpace;
-			this.isNewCompletion = isNewCompletion;
 		}
 		
 		public ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
@@ -70,14 +68,19 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			caretColumn          = textArea.Caret.Offset - document.GetLineSegment(caretLineNumber - 1).Offset + 1;
 			
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
-			string expression = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.GetText(0, textArea.Caret.Offset), textArea.Caret.Offset - 1);
+			string expression;
+			if (expressionFinder == null) {
+				expression = TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset);
+				context = ExpressionContext.Default;
+			} else {
+				ExpressionResult er = expressionFinder.FindExpression(textArea.Document.GetText(0, textArea.Caret.Offset), textArea.Caret.Offset - 1);
+				expression = er.Expression;
+				context = er.Context;
+			}
 			ResolveResult results;
 			preSelection  = null;
 			
 			if (ctrlSpace) {
-				if (isNewCompletion && expression == null) {
-					return null;
-				}
 				if (expression == null || expression.Length == 0) {
 					preSelection = "";
 					if (charTyped != '\0') {
@@ -110,25 +113,13 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			if (expression == null || expression.Length == 0) {
 				return null;
 			}
-			// do not instantiate service here as some checks might fail
-			// 
-			if (charTyped == ' ' && (expression.LastIndexOf("using")>=0 || expression.ToUpper().LastIndexOf("IMPORTS")>=0)) {
-				if (expression == "using" || expression.EndsWith(" using") || expression.EndsWith("\tusing")|| expression.EndsWith("\nusing")|| expression.EndsWith("\rusing") ||
-				    expression.ToUpper() == "IMPORTS" || expression.ToUpper().EndsWith(" IMPORTS") || expression.ToUpper().EndsWith("\tIMPORTS")|| expression.ToUpper().EndsWith("\nIMPORTS")|| expression.ToUpper().EndsWith("\rIMPORTS")) {
-					AddResolveResults(ParserService.CurrentProjectContent.GetNamespaceContents(""));
-				}
-			} else {
-				// we don't need to run parser on blank char here
-				if (charTyped == ' ') {
-					return null;
-				}
-				results = ParserService.Resolve(expression,
-				                                caretLineNumber,
-				                                caretColumn,
-				                                fileName,
-				                                document.TextContent);
-				AddResolveResults(results);
-			}
+			
+			results = ParserService.Resolve(expression,
+			                                caretLineNumber,
+			                                caretColumn,
+			                                fileName,
+			                                document.TextContent);
+			AddResolveResults(results);
 			
 			return (ICompletionData[])completionData.ToArray(typeof(ICompletionData));
 		}
@@ -140,6 +131,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 			completionData.Capacity += list.Count;
 			foreach (object o in list) {
+				if (context == ExpressionContext.Namespace && !(o is string)) continue;
 				if (o is string) {
 					completionData.Add(new CodeCompletionData(o.ToString(), ClassBrowserIconService.NamespaceIndex));
 				} else if (o is IClass) {

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

@@ -56,7 +56,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			initialOffset = textArea.Caret.Offset;
 			
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
-			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset - 1);
+			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset - 1).Expression;
 			if (word == null) // word can be null when cursor is in string/comment
 				return;
 			word = word.Trim();

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

@@ -57,7 +57,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			initialOffset = textArea.Caret.Offset;
 			
 			IExpressionFinder expressionFinder = ParserService.GetExpressionFinder(fileName);
-			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset - 1);
+			string word = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(textArea, textArea.Caret.Offset) : expressionFinder.FindExpression(textArea.Document.TextContent, textArea.Caret.Offset - 1).Expression;
 			if (word == null) // word can be null when cursor is in string/comment
 				return;
 			word = word.Trim();

src/Main/Base/Project/Src/TextEditor/Gui/Editor/ParserFoldingStrategy.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -22,7 +22,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			if (c.ClassType == ClassType.Delegate) {
 				return;
 			}
-			if (c.Region != null && c.Region.EndLine > 0) {
+			if (c.Region != null && c.Region.BeginLine < c.Region.EndLine) {
 				FoldMarker newFoldMarker = new FoldMarker(document, c.Region.BeginLine - 1, c.Region.BeginColumn - 1,
 				                               c.Region.EndLine - 1, c.Region.EndColumn, FoldType.TypeBody);
 				if (newFoldMarker.Length > 0) {
@@ -34,28 +34,28 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 			}
 			
 			foreach (IMethod m in c.Methods) {
-				if (m.BodyRegion != null && m.BodyRegion.EndLine > 0) {
+				if (m.BodyRegion != null && m.Region.EndLine < m.BodyRegion.EndLine) {
 					foldMarkers.Add(new FoldMarker(document, m.Region.EndLine - 1, m.Region.EndColumn - 1,
 					                               m.BodyRegion.EndLine - 1, m.BodyRegion.EndColumn - 1, FoldType.MemberBody));
 				}
 			}
 			
 			foreach (IIndexer indexer in c.Indexer) {
-				if (indexer.BodyRegion != null && indexer.BodyRegion.EndLine > 0) {
+				if (indexer.BodyRegion != null && indexer.Region.EndLine < indexer.BodyRegion.EndLine) {
 					foldMarkers.Add(new FoldMarker(document, indexer.Region.EndLine - 1,    indexer.Region.EndColumn - 1,
 					                               indexer.BodyRegion.EndLine- 1, indexer.BodyRegion.EndColumn - 1, FoldType.MemberBody));
 				}
 			}
 			
 			foreach (IProperty p in c.Properties) {
-				if (p.BodyRegion != null && p.BodyRegion.EndLine > 0) {
+				if (p.BodyRegion != null && p.Region.EndLine < p.BodyRegion.EndLine) {
 					foldMarkers.Add(new FoldMarker(document, p.Region.EndLine - 1, p.Region.EndColumn - 1,
 					                               p.BodyRegion.EndLine- 1, p.BodyRegion.EndColumn - 1, FoldType.MemberBody));
 				}
 			}
 			
 			foreach (IEvent evt in c.Events) {
-				if (evt.BodyRegion != null && evt.BodyRegion.EndLine > 0) {
+				if (evt.BodyRegion != null && evt.Region.EndLine < evt.BodyRegion.EndLine) {
 					if (evt.BodyRegion != null) {
 						foldMarkers.Add(new FoldMarker(document, evt.Region.EndLine - 1, evt.Region.EndColumn - 1,
 						                               evt.BodyRegion.EndLine- 1, evt.BodyRegion.EndColumn - 1, FoldType.MemberBody));

src/Main/Base/Project/Src/TextEditor/Gui/Editor/SharpDevelopTextAreaControl.cs

@@ -1,4 +1,4 @@
-// <file>
+// <file>
 //     <copyright see="prj:///doc/copyright.txt"/>
 //     <license see="prj:///doc/license.txt"/>
 //     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@@ -73,7 +73,7 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 		public virtual ICompletionDataProvider CreateCodeCompletionDataProvider(bool ctrlSpace)
 		{
 			//ivoko: please do not touch or discuss with me: we use another CCDP
-			return new CodeCompletionDataProvider(ctrlSpace, false);
+			return new CodeCompletionDataProvider(ctrlSpace);
 		}
 		
 		protected override void InitializeTextAreaControl(TextAreaControl newControl)

src/Main/Base/Test/ICSharpCode.SharpDevelop.Tests.csproj

@@ -44,6 +44,7 @@
     <Compile Include="NRefactoryResolverTests.cs" />
     <Compile Include="ReflectionLayerTests.cs" />
     <Compile Include="GenericResolverTests.cs" />
+    <Compile Include="InnerClassesResolverTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Project\ICSharpCode.SharpDevelop.csproj">

src/Main/Base/Test/InnerClassesResolverTests.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections;
+using System.IO;
+using NUnit.Framework;
+using ICSharpCode.Core;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
+
+namespace ICSharpCode.SharpDevelop.Tests
+{
+	[TestFixture]
+	public class InnerClassesResolverTests
+	{
+		#region Test helper methods
+		NRefactoryResolverTests nrrt = new NRefactoryResolverTests();
+		
+		ResolveResult Resolve(string program, string expression, int line)
+		{
+			return nrrt.Resolve(program, expression, line);
+		}
+		
+		ResolveResult ResolveVB(string program, string expression, int line)
+		{
+			return nrrt.ResolveVB(program, expression, line);
+		}
+		#endregion
+		
+		[Test]
+		public void OuterclassPrivateFieldResolveTest()
+		{
+			string program = @"class A
+{
+	int myField;
+	class B
+	{
+		void MyMethod(A a)
+		{
+		
+		}
+	}
+}
+";
+			ResolveResult result = Resolve(program, "a", 8);
+			Assert.IsNotNull(result, "result");
+			Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
+			ArrayList arr = result.GetCompletionData(nrrt.lastPC);
+			Assert.IsNotNull(arr, "arr");
+			foreach (object o in arr) {
+				if (o is IField) {
+					Assert.AreEqual("myField", ((IField)o).Name);
+					return;
+				}
+			}
+			Assert.Fail("private field not visible from inner class");
+		}
+	}
+}

src/Main/Base/Test/NRefactoryResolverTests.cs

@@ -32,7 +32,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 			return visitor.Cu;
 		}
 		
-		IProjectContent lastPC;
+		public IProjectContent lastPC;
 		
 		ICompilationUnit ParseVB(string fileName, string fileContent)
 		{
@@ -175,35 +175,6 @@ End Module
 			}
 			Assert.Fail("Length not found on array instance (resolve result was " + result.ResolvedType.ToString() + ")");
 		}
-		
-		[Test]
-		public void OuterclassPrivateFieldResolveTest()
-		{
-			string program = @"class A
-{
-	int myField;
-	class B
-	{
-		void MyMethod(A a)
-		{
-		
-		}
-	}
-}
-";
-			ResolveResult result = Resolve(program, "a", 8);
-			Assert.IsNotNull(result, "result");
-			Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
-			ArrayList arr = result.GetCompletionData(lastPC);
-			Assert.IsNotNull(arr, "arr");
-			foreach (object o in arr) {
-				if (o is IField) {
-					Assert.AreEqual("myField", ((IField)o).Name);
-					return;
-				}
-			}
-			Assert.Fail("private field not visible from inner class");
-		}
 		#endregion
 		
 		#region Simple Tests
@@ -353,6 +324,80 @@ interface IInterface2 {
 			Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'this.TargetMethod()'");
 		}
 		
+		[Test]
+		public void EventCallTest()
+		{
+			string program = @"using System;
+class A {
+	void Method() {
+		
+	}
+	
+	public event EventHandler TestEvent;
+}
+";
+			ResolveResult result = Resolve(program, "TestEvent(this, EventArgs.Empty)", 4);
+			Assert.IsNotNull(result);
+			Assert.IsTrue(result is MemberResolveResult);
+			Assert.AreEqual("A.TestEvent", (result as MemberResolveResult).ResolvedMember.FullyQualifiedName);
+		}
+		
+		[Test]
+		public void VoidTest()
+		{
+			string program = @"using System;
+class A {
+	void TestMethod() {
+		
+	}
+}
+";
+			ResolveResult result = Resolve(program, "TestMethod()", 4);
+			Assert.IsNotNull(result);
+			Assert.AreSame(ReflectionReturnType.Void, result.ResolvedType, result.ResolvedType.ToString());
+			Assert.AreEqual(0, result.GetCompletionData(lastPC).Count);
+		}
+		
+		[Test]
+		public void ThisEventCallTest()
+		{
+			string program = @"using System;
+class A {
+	void Method() {
+		
+	}
+	
+	public event EventHandler TestEvent;
+}
+";
+			ResolveResult result = Resolve(program, "this.TestEvent(this, EventArgs.Empty)", 4);
+			Assert.IsNotNull(result);
+			Assert.IsTrue(result is MemberResolveResult);
+			Assert.AreEqual("A.TestEvent", (result as MemberResolveResult).ResolvedMember.FullyQualifiedName);
+		}
+		
+		[Test]
+		public void DelegateCallTest()
+		{
+			string program = @"using System.Reflection;
+class A {
+	void Method() {
+		ModuleResolveEventHandler eh = SomeClass.SomeProperty;
+		
+	}
+}
+";
+			ResolveResult result = Resolve(program, "eh(this, new ResolveEventArgs())", 5);
+			Assert.IsNotNull(result);
+			Assert.IsTrue(result is LocalResolveResult);
+			Assert.AreEqual("eh", (result as LocalResolveResult).Field.Name);
+			
+			result = Resolve(program, "eh(this, new ResolveEventArgs()).GetType(\"bla\")", 5);
+			Assert.IsNotNull(result);
+			Assert.IsTrue(result is MemberResolveResult);
+			Assert.AreEqual("System.Reflection.Module.GetType", (result as MemberResolveResult).ResolvedMember.FullyQualifiedName);
+		}
+		
 		[Test]
 		public void OverloadLookupTest()
 		{
@@ -636,5 +681,79 @@ class A {
 			Assert.AreEqual("System.Collections.Generic", ns.Name, "COL.Generic");
 		}
 		#endregion
+		
+		#region Visibility tests
+		[Test]
+		public void PrivateMemberTest()
+		{
+			string program = @"using System;
+class A {
+	void TestMethod(B b) {
+		
+	}
+}
+class B {
+	int member;
+}
+";
+			ResolveResult result = Resolve(program, "b", 4);
+			Assert.IsNotNull(result);
+			ArrayList cd = result.GetCompletionData(lastPC);
+			Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup");
+			result = Resolve(program, "b.member", 4);
+			Assert.IsNotNull(result, "member should be found even though it is not visible!");
+		}
+		
+		[Test]
+		public void ProtectedVisibleMemberTest()
+		{
+			string program = @"using System;
+class A : B {
+	void TestMethod(B b) {
+		
+	}
+}
+class B {
+	protected int member;
+}
+";
+			ResolveResult result = Resolve(program, "b", 4);
+			Assert.IsNotNull(result);
+			ArrayList cd = result.GetCompletionData(lastPC);
+			Assert.IsTrue(MemberExists(cd, "member"), "member should be in completion lookup");
+			result = Resolve(program, "b.member", 4);
+			Assert.IsNotNull(result, "member should be found!");
+		}
+		
+		[Test]
+		public void ProtectedInvisibleMemberTest()
+		{
+			string program = @"using System;
+class A {
+	void TestMethod(B b) {
+		
+	}
+}
+class B {
+	protected int member;
+}
+";
+			ResolveResult result = Resolve(program, "b", 4);
+			Assert.IsNotNull(result);
+			ArrayList cd = result.GetCompletionData(lastPC);
+			Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup");
+			result = Resolve(program, "b.member", 4);
+			Assert.IsNotNull(result, "member should be found even though it is not visible!");
+		}
+		
+		bool MemberExists(ArrayList members, string name)
+		{
+			foreach (object o in members) {
+				IMember m = o as IMember;
+				if (m.Name == name) return true;
+			}
+			return false;
+		}
+		#endregion
 	}
 }

src/Main/Base/Test/ReflectionLayerTests.cs

@@ -95,5 +95,13 @@ namespace ICSharpCode.SharpDevelop.Tests
 			Assert.IsNotNull(inner, "UnderlyingClass");
 			Assert.AreEqual("System.Environment.SpecialFolder", inner.FullyQualifiedName);
 		}
+		
+		[Test]
+		public void VoidTest()
+		{
+			IClass c = pc.GetClass("System.Void");
+			Assert.IsNotNull(c, "System.Void not found");
+			Assert.AreSame(c.DefaultReturnType, ReflectionReturnType.Void, "ReflectionReturnType.Void is c.DefaultReturnType");
+		}
 	}
 }