Added code completion on type parameters in generic classes.

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

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

@@ -16,6 +16,8 @@ namespace CSharpBinding.Parser
 				return new ExpressionResult(null);
 			if (expression.StartsWith("using "))
 				return new ExpressionResult(expression.Substring(6).TrimStart(), ExpressionContext.Namespace, null);
+			if (!hadParenthesis && expression.StartsWith("new "))
+				return new ExpressionResult(expression.Substring(4).TrimStart(), ExpressionContext.ObjectCreation, null);
 			if (IsInAttribute(inText, offset))
 				return new ExpressionResult(expression, ExpressionContext.Attribute);
 			return new ExpressionResult(expression);
@@ -71,6 +73,7 @@ namespace CSharpBinding.Parser
 			this.text = inText;
 			this.offset = this.lastAccept = offset;
 			this.state  = START;
+			hadParenthesis = false;
 			if (this.text == null) {
 				return null;
 			}
@@ -454,6 +457,12 @@ namespace CSharpBinding.Parser
 			return tokenStateName[state];
 		}
 		
+		/// <summary>
+		/// used to control whether an expression is in a ObjectCreation context (new *expr*),
+		/// or is in the default context (e.g. "new MainForm().Show()", 'new ' is there part of the expression
+		/// </summary>
+		bool hadParenthesis;
+		
 		void ReadNextToken()
 		{
 			char ch;
@@ -475,6 +484,7 @@ namespace CSharpBinding.Parser
 					break;
 				case ')':
 					if (ReadBracket('(', ')')) {
+						hadParenthesis = true;
 						curTokenType = Parent;
 					}
 					break;

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

@@ -11,9 +11,12 @@ namespace VBNetBinding.Parser
 	{
 		ExpressionResult CreateResult(string expression)
 		{
-			if (expression != null && expression.Length > 8 && expression.Substring(0, 8).Equals("Imports ", StringComparison.InvariantCultureIgnoreCase))
+			if (expression == null)
+				return new ExpressionResult(null);
+			if (expression.Length > 8 && expression.Substring(0, 8).Equals("Imports ", StringComparison.InvariantCultureIgnoreCase))
 				return new ExpressionResult(expression.Substring(8).TrimStart(), ExpressionContext.Namespace, null);
-			else
+			if (expression.Length > 4 && expression.Substring(0, 4).Equals("New ", StringComparison.InvariantCultureIgnoreCase))
+				return new ExpressionResult(expression.Substring(4).TrimStart(), ExpressionContext.ObjectCreation, null);
 			return new ExpressionResult(expression);
 		}
 		

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

@@ -677,6 +677,7 @@
     <Compile Include="Src\Project\Items\ImportProjectItem.cs" />
     <Compile Include="Src\TextEditor\Gui\Editor\CompletionWindow\AttributesDataProvider.cs" />
     <Compile Include="Src\TextEditor\Gui\Editor\CompletionWindow\CtrlSpaceCompletionDataProvider.cs" />
+    <Compile Include="Src\Dom\Implementations\CombinedReturnType.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj">

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

@@ -12,12 +12,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 {
 	/// <summary>
 	/// Class describing a contexts in which an expressions can be.
-	/// Serves as filter for code completion results.
+	/// Serves as filter for code completion results, but the contexts exposed as static fields
+	/// can also be used as a kind of enumeration for special behaviour in the resolver.
 	/// </summary>
 	public abstract class ExpressionContext
 	{
 		public abstract bool ShowEntry(object o);
 		
+		#region Default contexts (public fields)
 		/// <summary>Default/unknown context</summary>
 		public static ExpressionContext Default = new DefaultExpressionContext();
 		
@@ -31,10 +33,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		/// <summary>Context expects a non-abstract type that has accessible constructors</summary>
 		/// <example>new *expr*();</example>
+		/// <remarks>When using this context, a resolver should treat the expression as object creation,
+		/// even when the keyword "new" is not part of the expression.</remarks>
 		public static ExpressionContext ObjectCreation = new TypeExpressionContext(null, true);
 		
 		/// <summary>Context expects a non-abstract type deriving from System.Attribute.</summary>
 		/// <example>[*expr*()]</example>
+		/// <remarks>When using this context, a resolver should try resolving typenames with an
+		/// appended "Attribute" suffix and treat "invocations" of the attribute type as
+		/// object creation.</remarks>
 		public static ExpressionContext Attribute = new TypeExpressionContext(ProjectContentRegistry.Mscorlib.GetClass("System.Attribute"), true);
 		
 		/// <summary>Context expects a type name which has special base type</summary>
@@ -45,23 +52,39 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			return new TypeExpressionContext(baseClass, mustBeConstructable);
 		}
+		#endregion
 		
+		#region DefaultExpressionContext
 		class DefaultExpressionContext : ExpressionContext
 		{
 			public override bool ShowEntry(object o)
 			{
 				return true;
 			}
+			
+			public override string ToString()
+			{
+				return "[" + GetType().Name + "]";
 			}
+		}
+		#endregion
 		
+		#region NamespaceExpressionContext
 		class NamespaceExpressionContext : ExpressionContext
 		{
 			public override bool ShowEntry(object o)
 			{
 				return o is string;
 			}
+			
+			public override string ToString()
+			{
+				return "[" + GetType().Name + "]";
+			}
 		}
+		#endregion
 		
+		#region TypeExpressionContext
 		class TypeExpressionContext : ExpressionContext
 		{
 			IClass baseClass;
@@ -88,6 +111,70 @@ namespace ICSharpCode.SharpDevelop.Dom
 					return true;
 				return c.IsTypeInInheritanceTree(baseClass);
 			}
+			
+			public override string ToString()
+			{
+				if (baseClass != null)
+					return "[" + GetType().Name + ": " + baseClass.FullyQualifiedName
+						+ " mustBeConstructable=" + mustBeConstructable + "]";
+				else
+					return "[" + GetType().Name + " mustBeConstructable=" + mustBeConstructable + "]";
+			}
+		}
+		#endregion
+		
+		#region CombinedExpressionContext
+		public static ExpressionContext operator | (ExpressionContext a, ExpressionContext b)
+		{
+			return new CombinedExpressionContext(0, a, b);
+		}
+		
+		public static ExpressionContext operator & (ExpressionContext a, ExpressionContext b)
+		{
+			return new CombinedExpressionContext(1, a, b);
+		}
+		
+		public static ExpressionContext operator ^ (ExpressionContext a, ExpressionContext b)
+		{
+			return new CombinedExpressionContext(2, a, b);
+		}
+		
+		class CombinedExpressionContext : ExpressionContext
+		{
+			byte opType; // 0 = or ; 1 = and ; 2 = xor
+			ExpressionContext a;
+			ExpressionContext b;
+			
+			public CombinedExpressionContext(byte opType, ExpressionContext a, ExpressionContext b)
+			{
+				if (a == null)
+					throw new ArgumentNullException("a");
+				if (b == null)
+					throw new ArgumentNullException("a");
+				this.opType = opType;
+				this.a = a;
+				this.b = b;
+			}
+			
+			public override bool ShowEntry(object o)
+			{
+				if (opType == 0)
+					return a.ShowEntry(o) || b.ShowEntry(o);
+				if (opType == 1)
+					return a.ShowEntry(o) && b.ShowEntry(o);
+				return a.ShowEntry(o) ^ b.ShowEntry(o);
+			}
+			
+			public override string ToString()
+			{
+				string op = " XOR ";
+				if (opType == 0)
+					op = " OR ";
+				else if (opType == 1)
+					op = " AND ";
+				return "[" + GetType().Name + ": " + a + op + b + "]";
+			}
 		}
+		#endregion
 	}
 }

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

@@ -36,6 +36,14 @@ namespace ICSharpCode.SharpDevelop.Dom
 		/// </summary>
 		IClass Class  { get; }
 		
-		// TODO: Constraint
+		/// <summary>
+		/// Gets the contraints of this type parameter.
+		/// </summary>
+		IList<IReturnType> Constraints { get; }
+		
+		/// <summary>
+		/// Gets if the type parameter has the 'new' constraint.
+		/// </summary>
+		bool HasConstructableContraint { get; }
 	}
 }

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

@@ -228,13 +228,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		public virtual int CompareTo(IDecoration value)
 		{
-			int cmp;
+			return this.Modifiers - value.Modifiers;
-			
-			if (0 != (cmp = (int)(Modifiers - value.Modifiers))) {
-				return cmp;
-			}
-			
-			return DiffUtility.Compare(Attributes, value.Attributes);
 		}
 		
 		int IComparable.CompareTo(object value)

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

@@ -0,0 +1,137 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Daniel Grunwald" email="daniel@danielgrunwald.de"/>
+//     <version value="$version"/>
+// </file>
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	/// <summary>
+	/// Combines multiple return types.
+	/// </summary>
+	public class CombinedReturnType : IReturnType
+	{
+		IList<IReturnType> baseTypes;
+		
+		string fullName;
+		string name;
+		string @namespace;
+		string dotnetName;
+		
+		public CombinedReturnType(IList<IReturnType> baseTypes, string fullName, string name, string @namespace, string dotnetName)
+		{
+			this.baseTypes = baseTypes;
+			this.fullName = fullName;
+			this.name = name;
+			this.@namespace = @namespace;
+			this.dotnetName = dotnetName;
+		}
+		
+		public IList<IReturnType> BaseTypes {
+			get {
+				return baseTypes;
+			}
+		}
+		
+		List<T> Combine<T>(Converter<IReturnType, List<T>> conv) where T : IMember
+		{
+			int count = baseTypes.Count;
+			if (count == 0)
+				return null;
+			List<T> list = null;
+			foreach (IReturnType baseType in baseTypes) {
+				List<T> newList = conv(baseType);
+				if (newList == null)
+					continue;
+				if (list == null) {
+					list = newList;
+				} else {
+					foreach (T element in newList) {
+						bool found = false;
+						foreach (T t in list) {
+							if (t.CompareTo(element) == 0) {
+								found = true;
+								break;
+							}
+						}
+						if (!found) {
+							list.Add(element);
+						}
+					}
+				}
+			}
+			return list;
+		}
+		
+		public List<IMethod> GetMethods()
+		{
+			return Combine<IMethod>(delegate(IReturnType type) { return type.GetMethods(); });
+		}
+		
+		public List<IProperty> GetProperties()
+		{
+			return Combine<IProperty>(delegate(IReturnType type) { return type.GetProperties(); });
+		}
+		
+		public List<IField> GetFields()
+		{
+			return Combine<IField>(delegate(IReturnType type) { return type.GetFields(); });
+		}
+		
+		public List<IEvent> GetEvents()
+		{
+			return Combine<IEvent>(delegate(IReturnType type) { return type.GetEvents(); });
+		}
+		
+		public List<IIndexer> GetIndexers()
+		{
+			return Combine<IIndexer>(delegate(IReturnType type) { return type.GetIndexers(); });
+		}
+		
+		public string FullyQualifiedName {
+			get {
+				return fullName;
+			}
+		}
+		
+		public string Name {
+			get {
+				return name;
+			}
+		}
+		
+		public string Namespace {
+			get {
+				return @namespace;
+			}
+		}
+		
+		public string DotNetName {
+			get {
+				return dotnetName;
+			}
+		}
+		
+		public int ArrayDimensions {
+			get {
+				return 0;
+			}
+		}
+		
+		public bool IsDefaultReturnType {
+			get {
+				return false;
+			}
+		}
+		
+		public IClass GetUnderlyingClass()
+		{
+			return null;
+		}
+	}
+}

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

@@ -197,41 +197,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 				if (cmp != 0) {
 					return cmp;
 				}
+				return this.TypeParameters.Count - value.TypeParameters.Count;
 			}
 			return -1;
-			/*
-			if (Region != null) {
-				cmp = Region.CompareTo(value.Region);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
-			cmp = DiffUtility.Compare(BaseTypes, value.BaseTypes);
-			if(cmp != 0)
-				return cmp;
-			
-			cmp = DiffUtility.Compare(InnerClasses, value.InnerClasses);
-			if(cmp != 0)
-				return cmp;
-			
-			cmp = DiffUtility.Compare(Fields, value.Fields);
-			if(cmp != 0)
-				return cmp;
-			
-			cmp = DiffUtility.Compare(Properties, value.Properties);
-			if(cmp != 0)
-				return cmp;
-			
-			cmp = DiffUtility.Compare(Indexer, value.Indexer);
-			if(cmp != 0)
-				return cmp;
-			
-			cmp = DiffUtility.Compare(Methods, value.Methods);
-			if(cmp != 0)
-				return cmp;
-			
-			return DiffUtility.Compare(Events, value.Events);*/
 		}
 		
 		int IComparable.CompareTo(object o)

src/Main/Base/Project/Src/Dom/Implementations/DefaultEvent.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"/>
@@ -64,13 +64,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 				return cmp;
 			
 			if (FullyQualifiedName != null) {
-				cmp = FullyQualifiedName.CompareTo(value.FullyQualifiedName);
+				return FullyQualifiedName.CompareTo(value.FullyQualifiedName);
-				if (cmp != 0) {
-					return cmp;
-				}
 			}
 			
-			return Region.CompareTo(value.Region);
+			return 0;
 		}
 		
 		int IComparable.CompareTo(object value)

src/Main/Base/Project/Src/Dom/Implementations/DefaultField.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"/>
@@ -44,21 +44,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 			
 			if (FullyQualifiedName != null) {
-				cmp = FullyQualifiedName.CompareTo(field.FullyQualifiedName);
+				return FullyQualifiedName.CompareTo(field.FullyQualifiedName);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
-			if (FullyQualifiedName != null) {
-				cmp = FullyQualifiedName.CompareTo(field.FullyQualifiedName);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
-			if (Region != null) {
-				return Region.CompareTo(field.Region);
 			}
 			return 0;
 		}

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

@@ -87,27 +87,6 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
-			if (Region != null) {
-				cmp = Region.CompareTo(value.Region);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
-			if (GetterRegion != null) {
-				cmp = GetterRegion.CompareTo(value.GetterRegion);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
-			if (SetterRegion != null) {
-				cmp = SetterRegion.CompareTo(value.SetterRegion);
-				if (cmp != 0) {
-					return cmp;
-				}
-			}
-			
 			return DiffUtility.Compare(Parameters, value.Parameters);
 		}
 		

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

@@ -20,6 +20,11 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 		}
 		
+		public Constructor(ModifierEnum m, IReturnType returnType)
+			: base("#ctor", returnType, m, null, null, null)
+		{
+		}
+		
 		/// <summary>
 		/// Creates a default constructor for the class.
 		/// The constructor has the region of the class and a documentation comment saying
@@ -165,12 +170,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 				}
 			}
 			
-			if (Region != null) {
+			cmp = this.TypeParameters.Count - value.TypeParameters.Count;
-				cmp = Region.CompareTo(value.Region);
 			if (cmp != 0) {
 				return cmp;
 			}
-			}
 			
 			return DiffUtility.Compare(Parameters, value.Parameters);
 		}

src/Main/Base/Project/Src/Dom/Implementations/DefaultProperty.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"/>
@@ -115,22 +115,7 @@ namespace ICSharpCode.SharpDevelop.Dom {
 				}
 			}
 			
-			if(0 != (cmp = Region.CompareTo(value.Region)))
+			return DiffUtility.Compare(Parameters, value.Parameters);
-				return cmp;
-			
-			if(SetterRegion != null && value.SetterRegion == null)
-				return 1;
-			
-			if(SetterRegion == null && value.SetterRegion != null)
-				return -1;
-			
-			if(GetterRegion != null && value.GetterRegion == null)
-				return 1;
-			
-			if(GetterRegion == null && value.GetterRegion != null)
-				return -1;
-			
-			return 0;
 		}
 		
 		int IComparable.CompareTo(object value) {

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

@@ -17,6 +17,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 	public class DefaultTypeParameter : ITypeParameter
 	{
 		string name;
+		IMethod method;
+		IClass targetClass;
+		int index;
+		List<IReturnType> constraints = new List<IReturnType>();
 		
 		public string Name {
 			get {
@@ -24,17 +28,12 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		int index;
-		
 		public int Index {
 			get {
 				return index;
 			}
 		}
 		
-		IMethod method;
-		IClass targetClass;
-		
 		public IMethod Method {
 			get {
 				return method;
@@ -47,6 +46,27 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public IList<IReturnType> Constraints {
+			get {
+				return constraints;
+			}
+		}
+		
+		bool hasConstructableContraint = false;
+		
+		/// <summary>
+		/// Gets if the type parameter has the 'new' constraint.
+		/// </summary>
+		public bool HasConstructableContraint {
+			get {
+				return hasConstructableContraint;
+			}
+			set {
+				hasConstructableContraint = value;
+			}
+		}
+		
+		
 		public DefaultTypeParameter(IMethod method, string name, int index)
 		{
 			this.method = method;
@@ -61,6 +81,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.targetClass = method.DeclaringType;
 			this.name = type.Name;
 			this.index = type.GenericParameterPosition;
+			foreach (Type constraint in type.GetGenericParameterConstraints()) {
+				constraints.Add(ReflectionReturnType.Create(targetClass.ProjectContent, constraint, false));
+			}
 		}
 		
 		public DefaultTypeParameter(IClass targetClass, string name, int index)
@@ -75,6 +98,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.targetClass = targetClass;
 			this.name = type.Name;
 			this.index = type.GenericParameterPosition;
+			foreach (Type constraint in type.GetGenericParameterConstraints()) {
+				constraints.Add(ReflectionReturnType.Create(targetClass.ProjectContent, constraint, false));
+			}
 		}
 		
 		public override string ToString()

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

@@ -76,11 +76,40 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
+		public override IClass GetUnderlyingClass()
+		{
+			return null;
+		}
+		
 		public override IReturnType BaseType {
 			get {
-				return null;
+				int count = typeParameter.Constraints.Count;
-				// return typeParameter.Constraint;
+				if (count == 0)
+					return ReflectionReturnType.Object;
+				if (count == 1)
+					return typeParameter.Constraints[0];
+				return new CombinedReturnType(typeParameter.Constraints,
+				                              FullyQualifiedName,
+				                              Name, Namespace,
+				                              DotNetName);
+			}
+		}
+		
+		// remove static methods (T.ReferenceEquals() is not possible)
+		public override List<IMethod> GetMethods()
+		{
+			List<IMethod> list = base.GetMethods();
+			if (list != null) {
+				for (int i = 0; i < list.Count; i++) {
+					if (list[i].IsStatic) {
+						list.RemoveAt(i--);
+					}
+				}
+				if (typeParameter.HasConstructableContraint) {
+					list.Add(new Constructor(ModifierEnum.Public, this));
+				}
 			}
+			return list;
 		}
 		
 		public override string ToString()

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

@@ -18,14 +18,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 	public sealed class SearchClassReturnType : ProxyReturnType
 	{
 		IClass declaringClass;
+		IProjectContent pc;
 		int caretLine;
 		int caretColumn;
 		string name;
 		string shortName;
 		
-		public SearchClassReturnType(IClass declaringClass, int caretLine, int caretColumn, string name)
+		public SearchClassReturnType(IProjectContent projectContent, IClass declaringClass, int caretLine, int caretColumn, string name)
 		{
+			if (declaringClass == null)
+				throw new ArgumentNullException("declaringClass");
 			this.declaringClass = declaringClass;
+			this.pc = projectContent;
 			this.caretLine = caretLine;
 			this.caretColumn = caretColumn;
 			this.name = name;
@@ -58,7 +62,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		// TODO: Cache BaseType until a new CompilationUnit is generated (static counter in ParserService)
 		public override IReturnType BaseType {
 			get {
-				IClass c = declaringClass.ProjectContent.SearchType(name, declaringClass, caretLine, caretColumn);
+				IClass c = pc.SearchType(name, declaringClass, caretLine, caretColumn);
 				return (c != null) ? c.DefaultReturnType : null;
 			}
 		}

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

@@ -9,7 +9,8 @@ using System;
 namespace ICSharpCode.SharpDevelop.Dom
 {
 	[Flags]
-	public enum ModifierEnum : uint {
+	public enum ModifierEnum : int // must be signed for AbstractDecoration.Compare
+	{
 		None       = 0,
 		
 		// Access 

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

@@ -278,8 +278,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					c.BaseTypes.Add(type);
 				}
 			}
-			ConvertTemplates(typeDeclaration.Templates, c);
 			currentClass.Push(c);
+			
+			ConvertTemplates(typeDeclaration.Templates, c); // resolve constrains in context of the class
+			
 			object ret = typeDeclaration.AcceptChildren(this, data);
 			currentClass.Pop();
 			
@@ -305,7 +307,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			int index = 0;
 			foreach (AST.TemplateDefinition template in templateList) {
-				c.TypeParameters.Add(new DefaultTypeParameter(c, template.Name, index++));
+				c.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(c, template.Name, index++)));
 			}
 		}
 		
@@ -313,10 +315,18 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		{
 			int index = 0;
 			foreach (AST.TemplateDefinition template in templateList) {
-				m.TypeParameters.Add(new DefaultTypeParameter(m, template.Name, index++));
+				m.TypeParameters.Add(ConvertConstraints(template, new DefaultTypeParameter(m, template.Name, index++)));
 			}
 		}
 		
+		DefaultTypeParameter ConvertConstraints(AST.TemplateDefinition template, DefaultTypeParameter typeParameter)
+		{
+			foreach (AST.TypeReference typeRef in template.Bases) {
+				typeParameter.Constraints.Add(CreateReturnType(typeRef));
+			}
+			return typeParameter;
+		}
+		
 		public override object Visit(AST.DelegateDeclaration delegateDeclaration, object data)
 		{
 			DefaultRegion region = GetRegion(delegateDeclaration.StartLocation, delegateDeclaration.EndLocation);
@@ -363,7 +373,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IParameter CreateParameter(AST.ParameterDeclarationExpression par)
 		{
-			IReturnType parType = CreateReturnType(par.TypeReference);
+			return CreateParameter(par, null);
+		}
+		
+		IParameter CreateParameter(AST.ParameterDeclarationExpression par, IMethod method)
+		{
+			IReturnType parType = CreateReturnType(par.TypeReference, method);
 			DefaultParameter p = new DefaultParameter(par.ParameterName, parType, null);
 			p.Modifiers = (ParameterModifiers)par.ParamModifier;
 			return p;
@@ -382,7 +397,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			method.Attributes.AddRange(VisitAttributes(methodDeclaration.Attributes));
 			if (methodDeclaration.Parameters != null) {
 				foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) {
-					method.Parameters.Add(CreateParameter(par));
+					method.Parameters.Add(CreateParameter(par, method));
 				}
 			}
 			c.Methods.Add(method);
@@ -510,20 +525,15 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		IReturnType CreateReturnType(AST.TypeReference reference, IMethod method)
 		{
-			if (method.TypeParameters != null) {
+			IClass c = GetCurrentClass();
-				foreach (ITypeParameter tp in method.TypeParameters) {
+			if (c == null)
-					if (tp.Name.Equals(reference.SystemType, StringComparison.InvariantCultureIgnoreCase))
+				return null;
-						return new GenericReturnType(tp);
+			return TypeVisitor.CreateReturnType(reference, c, method, c.Region.BeginLine + 1, 1, cu.ProjectContent, true);
-				}
-			}
-			return CreateReturnType(reference);
 		}
 		
 		IReturnType CreateReturnType(AST.TypeReference reference)
 		{
-			IClass c = GetCurrentClass();
+			return CreateReturnType(reference, null);
-			if (c == null) return null;
-			return TypeVisitor.CreateReturnType(reference, c, c.Region.BeginLine + 1, 1);
 		}
 		
 		IReturnType CreateReturnType(Type type)

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

@@ -57,6 +57,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 		}
 		
+		public IMember CallingMember {
+			get {
+				return callingMember;
+			}
+		}
+		
 		public int CaretLine {
 			get {
 				return caretLine;
@@ -112,6 +118,10 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			}
 			expression = expression.TrimStart();
 			
+			if (expressionResult.Context == ExpressionContext.ObjectCreation) {
+				expression = "new " + expression;
+			}
+			
 			this.caretLine   = caretLineNumber;
 			this.caretColumn = caretColumn;
 			
@@ -258,9 +268,7 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 					if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) {
 						type = TypeVisitor.CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference, this);
 						if (type != null) {
-							IClass c = type.GetUnderlyingClass();
+							return new TypeResolveResult(callingClass, callingMember, type);
-							if (c != null)
-								return new TypeResolveResult(callingClass, callingMember, type, c);
 						}
 					}
 				}
@@ -431,7 +439,22 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			
 			IClass c = SearchType(identifier);
 			if (c != null) {
-				result2 = new TypeResolveResult(callingClass, callingMember, c.DefaultReturnType, c);
+				result2 = new TypeResolveResult(callingClass, callingMember, c);
+			} else {
+				if (callingClass != null) {
+					if (callingMember is IMethod) {
+						foreach (ITypeParameter typeParameter in (callingMember as IMethod).TypeParameters) {
+							if (IsSameName(identifier, typeParameter.Name)) {
+								return new TypeResolveResult(callingClass, callingMember, new GenericReturnType(typeParameter));
+							}
+						}
+					}
+					foreach (ITypeParameter typeParameter in callingClass.TypeParameters) {
+						if (IsSameName(identifier, typeParameter.Name)) {
+							return new TypeResolveResult(callingClass, callingMember, new GenericReturnType(typeParameter));
+						}
+					}
+				}
 			}
 			
 			if (result == null)  return result2;

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

@@ -448,51 +448,54 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		
 		public static IReturnType CreateReturnType(TypeReference reference, NRefactoryResolver resolver)
 		{
-			if (reference.IsNull) return null;
+			return CreateReturnType(reference,
-			IClass callingClass = resolver.CallingClass;
+			                        resolver.CallingClass, resolver.CallingMember,
-			IClass c = resolver.SearchType(reference.SystemType);
+			                        resolver.CaretLine, resolver.CaretColumn,
-			if (c == null) return null;
+			                        resolver.ProjectContent, false);
-			IReturnType t = c.DefaultReturnType;
-			if (callingClass != null) {
-				foreach (ITypeParameter tp in callingClass.TypeParameters) {
-					if (resolver.LanguageProperties.NameComparer.Equals(reference.SystemType, tp.Name)) {
-						t = new GenericReturnType(tp);
-						break;
-					}
-				}
-			}
-			if (reference.GenericTypes.Count > 0) {
-				List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count);
-				for (int i = 0; i < reference.GenericTypes.Count; ++i) {
-					para.Add(CreateReturnType(reference.GenericTypes[i], resolver));
-				}
-				t = new SpecificReturnType(t, para);
-			}
-			return WrapArray(t, reference);
 		}
 		
-		public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, int caretLine, int caretColumn)
+		public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass,
+		                                           IMember callingMember, int caretLine, int caretColumn,
+		                                           IProjectContent projectContent,
+		                                           bool useLazyReturnType)
 		{
+			if (reference == null) return null;
 			if (reference.IsNull) return null;
+			LanguageProperties languageProperties = projectContent.Language;
 			IReturnType t = null;
+			if (callingClass != null) {
 				foreach (ITypeParameter tp in callingClass.TypeParameters) {
-				if (tp.Name.Equals(reference.SystemType, StringComparison.InvariantCultureIgnoreCase)) {
+					if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) {
 						t = new GenericReturnType(tp);
 						break;
 					}
 				}
+			}
+			if (callingMember is IMethod && (callingMember as IMethod).TypeParameters != null) {
+				foreach (ITypeParameter tp in (callingMember as IMethod).TypeParameters) {
+					if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType))
+						return new GenericReturnType(tp);
+				}
+			}
 			if (t == null) {
 				if (reference.Type != reference.SystemType) {
 					// keyword-type like void, int, string etc.
 					t = ProjectContentRegistry.Mscorlib.GetClass(reference.SystemType).DefaultReturnType;
 				} else {
-					t = new SearchClassReturnType(callingClass, caretLine, caretColumn, reference.SystemType);
+					if (useLazyReturnType) {
+						t = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.SystemType);
+					} else {
+						IClass c = projectContent.SearchType(reference.SystemType, callingClass, caretLine, caretColumn);
+						if (c == null)
+							return null;
+						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) {
-					para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, caretLine, caretColumn));
+					para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, useLazyReturnType));
 				}
 				t = new SpecificReturnType(t, para);
 			}

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

@@ -273,8 +273,15 @@ namespace ICSharpCode.SharpDevelop.Dom
 			this.resolvedClass = resolvedClass;
 		}
 		
+		public TypeResolveResult(IClass callingClass, IMember callingMember, IReturnType resolvedType)
+			: base(callingClass, callingMember, resolvedType)
+		{
+			this.resolvedClass = resolvedType.GetUnderlyingClass();
+		}
+		
 		/// <summary>
 		/// Gets the class corresponding to the resolved type.
+		/// This property can be null when the type has no class (for example a type parameter).
 		/// </summary>
 		public IClass ResolvedClass {
 			get {
@@ -285,19 +292,19 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public override ArrayList GetCompletionData(IProjectContent projectContent)
 		{
 			ArrayList ar = GetCompletionData(projectContent.Language, true);
+			if (resolvedClass != null) {
 				ar.AddRange(resolvedClass.InnerClasses);
+			}
 			return ar;
 		}
 		
 		public override FilePosition GetDefinitionPosition()
 		{
-			ICompilationUnit cu = resolvedClass.CompilationUnit;
+			if (resolvedClass == null) {
-			if (cu == null) {
-				Console.WriteLine("resolvedClass.CompilationUnit is null");
 				return null;
 			}
-			if (cu.FileName == null || cu.FileName.Length == 0) {
+			ICompilationUnit cu = resolvedClass.CompilationUnit;
-				Console.WriteLine("resolvedClass.CompilationUnit.FileName is empty");
+			if (cu == null || cu.FileName == null || cu.FileName.Length == 0) {
 				return null;
 			}
 			IRegion reg = resolvedClass.Region;

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

@@ -385,8 +385,7 @@ namespace ICSharpCode.Core
 			if (result == null)
 				return null;
 			IAmbience ambience = AmbienceService.CurrentAmbience;
-			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags
+			ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
-				| ConversionFlags.ShowAccessibility;
 			if (result is MemberResolveResult) {
 				return GetText(ambience, ((MemberResolveResult)result).ResolvedMember);
 			} else if (result is LocalResolveResult) {
@@ -412,7 +411,11 @@ namespace ICSharpCode.Core
 			} else if (result is NamespaceResolveResult) {
 				return "namespace " + ((NamespaceResolveResult)result).Name;
 			} else if (result is TypeResolveResult) {
-				return GetText(ambience, ((TypeResolveResult)result).ResolvedClass);
+				IClass c = ((TypeResolveResult)result).ResolvedClass;
+				if (c != null)
+					return GetText(ambience, c);
+				else
+					return ambience.Convert(result.ResolvedType);
 			} else if (result is MethodResolveResult) {
 				IReturnType container = ((MethodResolveResult)result).ContainingType;
 				List<IMethod> methods = container.GetMethods();

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

@@ -135,7 +135,8 @@ namespace ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor
 						methods.Add(method);
 					}
 				}
-				if (methods.Count == 0 && !result.ResolvedClass.IsAbstract && !result.ResolvedClass.IsStatic) {
+				
+				if (methods.Count == 0 && result.ResolvedClass != null && !result.ResolvedClass.IsAbstract && !result.ResolvedClass.IsStatic) {
 					// add default constructor
 					methods.Add(Constructor.CreateDefault(result.ResolvedClass));
 				}

src/Main/Base/Test/GenericResolverTests.cs

@@ -25,6 +25,7 @@ namespace ICSharpCode.SharpDevelop.Tests
 		}
 		#endregion
 		
+		#region Generic references
 		const string listProgram = @"using System.Collections.Generic;
 class TestClass {
 	void Method() {
@@ -108,5 +109,73 @@ class TestClass {
 			MemberResolveResult mrr = (MemberResolveResult) result;
 			Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName);
 		}
+		#endregion
+		
+		#region CodeCompletion inside generic classes
+		const string genericClass = @"using System;
+public class GenericClass<T> where T : IDisposable
+	void Method<G>(T par1, G par2) where G : IConvertible, IFormattable {
+		T var1; G var2;
+		
+	}
+}
+";
+		
+		[Test]
+		public void ClassTypeParameterResolveType()
+		{
+			ResolveResult rr = Resolve(genericClass, "T", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is TypeResolveResult);
+			Assert.IsNull((rr as TypeResolveResult).ResolvedClass);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		
+		[Test]
+		public void ClassTypeParameterResolveVariable()
+		{
+			ResolveResult rr = Resolve(genericClass, "var1", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is LocalResolveResult);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		
+		[Test]
+		public void ClassTypeParameterResolveParameter()
+		{
+			ResolveResult rr = Resolve(genericClass, "par1", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is LocalResolveResult);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		
+		[Test]
+		public void MethodTypeParameterResolveType()
+		{
+			ResolveResult rr = Resolve(genericClass, "G", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is TypeResolveResult);
+			Assert.IsNull((rr as TypeResolveResult).ResolvedClass);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		
+		[Test]
+		public void MethodTypeParameterResolveVariable()
+		{
+			ResolveResult rr = Resolve(genericClass, "var2", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is LocalResolveResult);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		
+		[Test]
+		public void MethodTypeParameterResolveParameter()
+		{
+			ResolveResult rr = Resolve(genericClass, "par2", 5);
+			Assert.IsNotNull(rr);
+			Assert.IsTrue(rr is LocalResolveResult);
+			Assert.IsTrue(rr.ResolvedType is GenericReturnType);
+		}
+		#endregion
 	}
 }

src/SharpDevelop.sln

@@ -1,35 +1,5 @@
 Microsoft Visual Studio Solution File, Format Version 9.00
-# SharpDevelop 2.0.0.1
+# SharpDevelop 2.0.0.219
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Main", "Main", "{5A3EBEBA-0560-41C1-966B-23F7D03A5486}"
-	ProjectSection(SolutionItems) = postProject
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Tests", "Main\Base\Test\ICSharpCode.SharpDevelop.Tests.csproj", "{4980B743-B32F-4aba-AABD-45E2CAD3568D}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop", "Main\Base\Project\ICSharpCode.SharpDevelop.csproj", "{2748AD25-9C63-4E12-877B-4DCE96FBED54}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core", "Main\Core\Project\ICSharpCode.Core.csproj", "{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StartUp", "Main\StartUp\Project\StartUp.csproj", "{1152B71B-3C05-4598-B20D-823B5D40559E}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Tests", "Main\Core\Test\ICSharpCode.Core.Tests.csproj", "{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Libraries", "Libraries", "{9421EDF4-9769-4BE9-B5A6-C87DE221D73C}"
-	ProjectSection(SolutionItems) = postProject
-	EndProjectSection
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.framework.dll", "Tools\NUnit\src\NUnitFramework\framework\nunit.framework.dll.csproj", "{83DD7E12-A705-4DBA-9D71-09C8973D9382}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.dll", "Tools\NUnit\src\NUnitFramework\core\nunit.core.dll.csproj", "{EBD43A7F-AFCA-4281-BB53-5CDD91F966A3}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WinFormsUI", "Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj", "{D3C782BA-178E-4235-A3BA-8C11DEBB6BEE}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TextEditor", "Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj", "{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Libraries\NRefactory\Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.extensions.dll", "Tools\NUnit\src\NUnitFramework\extensions\nunit.extensions.dll.csproj", "{98B10E98-003C-45A0-9587-119142E39986}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AddIns", "AddIns", "{14A277EE-7DF1-4529-B639-7D1EF334C1C5}"
 	ProjectSection(SolutionItems) = postProject
 	EndProjectSection
@@ -78,6 +48,36 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StartPage", "AddIns\Misc\St
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AddinScout", "AddIns\Misc\AddinScout\Project\AddinScout.csproj", "{4B8F0F98-8BE1-402B-AA8B-C8D548577B38}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Libraries", "Libraries", "{9421EDF4-9769-4BE9-B5A6-C87DE221D73C}"
+	ProjectSection(SolutionItems) = postProject
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.framework.dll", "Tools\NUnit\src\NUnitFramework\framework\nunit.framework.dll.csproj", "{83DD7E12-A705-4DBA-9D71-09C8973D9382}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.dll", "Tools\NUnit\src\NUnitFramework\core\nunit.core.dll.csproj", "{EBD43A7F-AFCA-4281-BB53-5CDD91F966A3}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WinFormsUI", "Libraries\DockPanel_Src\WinFormsUI\WinFormsUI.csproj", "{D3C782BA-178E-4235-A3BA-8C11DEBB6BEE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.TextEditor", "Libraries\ICSharpCode.TextEditor\Project\ICSharpCode.TextEditor.csproj", "{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Libraries\NRefactory\Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.extensions.dll", "Tools\NUnit\src\NUnitFramework\extensions\nunit.extensions.dll.csproj", "{98B10E98-003C-45A0-9587-119142E39986}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Main", "Main", "{5A3EBEBA-0560-41C1-966B-23F7D03A5486}"
+	ProjectSection(SolutionItems) = postProject
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop.Tests", "Main\Base\Test\ICSharpCode.SharpDevelop.Tests.csproj", "{4980B743-B32F-4aba-AABD-45E2CAD3568D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.SharpDevelop", "Main\Base\Project\ICSharpCode.SharpDevelop.csproj", "{2748AD25-9C63-4E12-877B-4DCE96FBED54}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core", "Main\Core\Project\ICSharpCode.Core.csproj", "{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StartUp", "Main\StartUp\Project\StartUp.csproj", "{1152B71B-3C05-4598-B20D-823B5D40559E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.Core.Tests", "Main\Core\Test\ICSharpCode.Core.Tests.csproj", "{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -159,17 +159,6 @@ Global
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{1152B71B-3C05-4598-B20D-823B5D40559E} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{2748AD25-9C63-4E12-877B-4DCE96FBED54} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{4980B743-B32F-4aba-AABD-45E2CAD3568D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
-		{98B10E98-003C-45A0-9587-119142E39986} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{D3C782BA-178E-4235-A3BA-8C11DEBB6BEE} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{EBD43A7F-AFCA-4281-BB53-5CDD91F966A3} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
-		{83DD7E12-A705-4DBA-9D71-09C8973D9382} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
 		{CE5B42B7-6E8C-4385-9E97-F4023FC16BF2} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
 		{FEB825FA-4AD8-425D-8E4A-B5A18EE1B81C} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
 		{4EA396ED-64AD-4AD0-A67A-AB363F3E0C79} = {14A277EE-7DF1-4529-B639-7D1EF334C1C5}
@@ -188,5 +177,16 @@ Global
 		{B08385CD-F0CC-488C-B4F4-EEB34B6D2688} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
 		{1D18D788-F7EE-4585-A23B-34DC8EC63CB8} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
 		{EC06F96A-AEEC-49D6-B03D-AB87C6EB674C} = {6604365C-C702-4C10-9BA8-637F1E3D4D0D}
+		{98B10E98-003C-45A0-9587-119142E39986} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{2D18BE89-D210-49EB-A9DD-2246FBB3DF6D} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{D3C782BA-178E-4235-A3BA-8C11DEBB6BEE} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{EBD43A7F-AFCA-4281-BB53-5CDD91F966A3} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{83DD7E12-A705-4DBA-9D71-09C8973D9382} = {9421EDF4-9769-4BE9-B5A6-C87DE221D73C}
+		{AD6FAA08-D6F5-4DBA-AF85-F4DA9F40C3B5} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{1152B71B-3C05-4598-B20D-823B5D40559E} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{35CEF10F-2D4C-45F2-9DD1-161E0FEC583C} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{2748AD25-9C63-4E12-877B-4DCE96FBED54} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
+		{4980B743-B32F-4aba-AABD-45E2CAD3568D} = {5A3EBEBA-0560-41C1-966B-23F7D03A5486}
 	EndGlobalSection
 EndGlobal

src/Tools/UpdateAssemblyInfo/Main.cs

@@ -69,8 +69,18 @@ namespace UpdateAssemblyInfo
 			using (StreamReader r = new StreamReader(mainConfig + "AssemblyInfo.template")) {
 				content = r.ReadToEnd();
 			}
+			content = content.Replace("-INSERTREVISION-", revisionNumber);
+			if (File.Exists(mainConfig + "AssemblyInfo.cs")) {
+				using (StreamReader r = new StreamReader(mainConfig + "AssemblyInfo.cs")) {
+					if (r.ReadToEnd() == content) {
+						// nothing changed, do not overwrite file to prevent recompilation of StartUp
+						// every time.
+						return;
+					}
+				}
+			}
 			using (StreamWriter w = new StreamWriter(mainConfig + "AssemblyInfo.cs", false, Encoding.UTF8)) {
-				w.Write(content.Replace("-INSERTREVISION-", revisionNumber));
+				w.Write(content);
 			}
 		}