Type parameters are now included in CtrlSpace list.

Prevent exception on invalid constraints declarations.
Fixed forum-12689: InvalidCastException when ${property:...}-Tag is used to get a property that is not of type string.

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

src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs

@@ -912,7 +912,7 @@ out type);
 				break;
 			}
 		}
-		if ( td != null) { td.Bases.Add(type); }
+		if ( td != null && type != null) { td.Bases.Add(type); }
 		
 		while (la.kind == 14) {
 			lexer.NextToken();
@@ -928,7 +928,7 @@ out type);
 					break;
 				}
 			}
-			if ( td != null) { td.Bases.Add(type); }
+			if ( td != null && type != null) { td.Bases.Add(type); }
 			
 		}
 	}

src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG

@@ -2037,7 +2037,7 @@ TypeParameterConstraintsClause<List<TemplateDefinition> templates>
 	                                                		break;
 	                                                	}
 	                                                }
-	                                                if ( td != null) { td.Bases.Add(type); }
+	                                                if ( td != null && type != null) { td.Bases.Add(type); }
 	                                             .)
 	{ "," TypeParameterConstraintsClauseBase<out type> (.
 	                                                    td = null;
@@ -2047,7 +2047,7 @@ TypeParameterConstraintsClause<List<TemplateDefinition> templates>
 	                                                    		break;
 	                                                    	}
 	                                                    }
-	                                                    if ( td != null) { td.Bases.Add(type); }
+	                                                    if ( td != null && type != null) { td.Bases.Add(type); }
 	                                                   .) }
 .
 

src/Libraries/NRefactory/Test/Parser/TypeLevel/MethodDeclarationTests.cs

@@ -184,6 +184,18 @@ namespace ICSharpCode.NRefactory.Tests.Ast
 			Assert.AreEqual("MyInterface", md.InterfaceImplementations[0].InterfaceType.Type);
 			Assert.AreEqual("System.String", md.InterfaceImplementations[0].InterfaceType.GenericTypes[0].SystemType);
 		}
+		
+		[Test]
+		public void CSharpIncompleteConstraintsTest()
+		{
+			MethodDeclaration md = ParseUtilCSharp.ParseTypeMember<MethodDeclaration>(
+				"void a<T>() where T { }", true /* expect errors */
+			);
+			Assert.AreEqual("a", md.Name);
+			Assert.AreEqual(1, md.Templates.Count);
+			Assert.AreEqual("T", md.Templates[0].Name);
+			Assert.AreEqual(0, md.Templates[0].Bases.Count);
+		}
 		#endregion
 		
 		#region VB.NET

src/Main/Base/Project/Src/Gui/Workbench/Layouts/SdiWorkspaceLayout.cs

@@ -32,7 +32,9 @@ namespace ICSharpCode.SharpDevelop.Gui
 		ToolStripContainer toolStripContainer;
 		AutoHideMenuStripContainer mainMenuContainer;
 		AutoHideStatusStripContainer statusStripContainer;
+		#if DEBUG
 		static bool firstTimeError = true; // TODO: Debug statement only, remove me
+		#endif
 		
 		public IWorkbenchWindow ActiveWorkbenchwindow {
 			get {

src/Main/Core/Project/Src/Services/PropertyService/Properties.cs

@@ -286,6 +286,9 @@ namespace ICSharpCode.Core
 				}
 				o = arr;
 				properties[property] = o; // store for future look up
+			} else if (!(o is string) && typeof(T) == typeof(string)) {
+				TypeConverter c = TypeDescriptor.GetConverter(typeof(T));
+				o = c.ConvertToInvariantString(o);
 			}
 			try {
 				return (T)o;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultMethod.cs

@@ -20,8 +20,8 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 		}
 		
-		public Constructor(ModifierEnum m, IReturnType returnType)
-			: base("#ctor", returnType, m, DomRegion.Empty, DomRegion.Empty, null)
+		public Constructor(ModifierEnum m, IReturnType returnType, IClass declaringType)
+			: base("#ctor", returnType, m, DomRegion.Empty, DomRegion.Empty, declaringType)
 		{
 		}
 		

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/DefaultTypeParameter.cs

@@ -59,20 +59,33 @@ namespace ICSharpCode.SharpDevelop.Dom
 			}
 		}
 		
-		bool hasConstructableContraint = false;
+		bool hasConstructableConstraint = false;
+		bool hasReferenceTypeConstraint = false;
+		bool hasValueTypeConstraint = false;
 		
 		/// <summary>
-		/// Gets if the type parameter has the 'new' constraint.
+		/// Gets/Sets if the type parameter has the 'new()' constraint.
 		/// </summary>
-		public bool HasConstructableContraint {
-			get {
-				return hasConstructableContraint;
-			}
-			set {
-				hasConstructableContraint = value;
-			}
+		public bool HasConstructableConstraint {
+			get { return hasConstructableConstraint; }
+			set { hasConstructableConstraint = value; }
 		}
 		
+		/// <summary>
+		/// Gets/Sets if the type parameter has the 'class' constraint.
+		/// </summary>
+		public bool HasReferenceTypeConstraint {
+			get { return hasReferenceTypeConstraint; }
+			set { hasReferenceTypeConstraint = value; }
+		}
+		
+		/// <summary>
+		/// Gets/Sets if the type parameter has the 'struct' constraint.
+		/// </summary>
+		public bool HasValueTypeConstraint {
+			get { return hasValueTypeConstraint; }
+			set { hasValueTypeConstraint = value; }
+		}
 		
 		public DefaultTypeParameter(IMethod method, string name, int index)
 		{
@@ -110,7 +123,9 @@ namespace ICSharpCode.SharpDevelop.Dom
 			if (tp == null) return false;
 			if (tp.index != index) return false;
 			if (tp.name != name) return false;
-			if (tp.hasConstructableContraint != hasConstructableContraint) return false;
+			if (tp.hasConstructableConstraint != hasConstructableConstraint) return false;
+			if (tp.hasReferenceTypeConstraint != hasReferenceTypeConstraint) return false;
+			if (tp.hasValueTypeConstraint != hasValueTypeConstraint) return false;
 			if (tp.method != method) {
 				if (tp.method == null || method == null) return false;
 				if (tp.method.FullyQualifiedName == method.FullyQualifiedName) return false;
@@ -129,5 +144,24 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			return String.Format("[{0}: {1}]", GetType().Name, name);
 		}
+		
+		public static DefaultClass GetDummyClassForTypeParameter(ITypeParameter p)
+		{
+			DefaultClass c = new DefaultClass(p.Class.CompilationUnit, p.Name);
+			if (p.Method != null) {
+				c.Region = new DomRegion(p.Method.Region.BeginLine, p.Method.Region.BeginColumn);
+			} else {
+				c.Region = new DomRegion(p.Class.Region.BeginLine, p.Class.Region.BeginColumn);
+			}
+			c.Modifiers = ModifierEnum.Public;
+			if (p.HasValueTypeConstraint) {
+				c.ClassType = ClassType.Struct;
+			} else if (p.HasConstructableConstraint) {
+				c.ClassType = ClassType.Class;
+			} else {
+				c.ClassType = ClassType.Interface;
+			}
+			return c;
+		}
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Implementations/GenericReturnType.cs

@@ -27,7 +27,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			IReturnType rt = o as IReturnType;
 			if (rt == null || !rt.IsGenericReturnType)
-			    return false;
+				return false;
 			return typeParameter.Equals(rt.CastToGenericReturnType().typeParameter);
 		}
 		
@@ -94,13 +94,10 @@ namespace ICSharpCode.SharpDevelop.Dom
 		{
 			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));
+				list.RemoveAll(delegate(IMethod m) { return m.IsStatic || m.IsConstructor; });
+				if (typeParameter.HasConstructableConstraint || typeParameter.HasValueTypeConstraint) {
+					list.Add(new Constructor(ModifierEnum.Public, this,
+					                         DefaultTypeParameter.GetDummyClassForTypeParameter(typeParameter)));
 				}
 			}
 			return list;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/Interfaces/ITypeParameter.cs

@@ -44,8 +44,18 @@ namespace ICSharpCode.SharpDevelop.Dom
 		IList<IReturnType> Constraints { get; }
 		
 		/// <summary>
-		/// Gets if the type parameter has the 'new' constraint.
+		/// Gets if the type parameter has the 'new()' constraint.
 		/// </summary>
-		bool HasConstructableContraint { get; }
+		bool HasConstructableConstraint { get; }
+		
+		/// <summary>
+		/// Gets if the type parameter has the 'class' constraint.
+		/// </summary>
+		bool HasReferenceTypeConstraint { get; }
+		
+		/// <summary>
+		/// Gets if the type parameter has the 'struct' constraint.
+		/// </summary>
+		bool HasValueTypeConstraint { get; }
 	}
 }

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/NRefactoryASTConvertVisitor.cs

@@ -370,9 +370,17 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 		DefaultTypeParameter ConvertConstraints(AST.TemplateDefinition template, DefaultTypeParameter typeParameter)
 		{
 			foreach (AST.TypeReference typeRef in template.Bases) {
-				IReturnType rt = CreateReturnType(typeRef);
-				if (rt != null) {
-					typeParameter.Constraints.Add(rt);
+				if (typeRef == AST.TypeReference.NewConstraint) {
+					typeParameter.HasConstructableConstraint = true;
+				} else if (typeRef == AST.TypeReference.ClassConstraint) {
+					typeParameter.HasReferenceTypeConstraint = true;
+				} else if (typeRef == AST.TypeReference.StructConstraint) {
+					typeParameter.HasValueTypeConstraint = true;
+				} else {
+					IReturnType rt = CreateReturnType(typeRef);
+					if (rt != null) {
+						typeParameter.Constraints.Add(rt);
+					}
 				}
 			}
 			return typeParameter;

src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/NRefactoryResolver/NRefactoryResolver.cs

@@ -1065,6 +1065,19 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 			return result;
 		}
 		
+		static void AddTypeParametersForCtrlSpace(ArrayList result, IEnumerable<ITypeParameter> typeParameters)
+		{
+			foreach (ITypeParameter p in typeParameters) {
+				DefaultClass c = DefaultTypeParameter.GetDummyClassForTypeParameter(p);
+				if (p.Method != null) {
+					c.Documentation = "Type parameter of " + p.Method.Name;
+				} else {
+					c.Documentation = "Type parameter of " + p.Class.Name;
+				}
+				result.Add(c);
+			}
+		}
+		
 		public static void AddContentsFromCalling(ArrayList result, IClass callingClass, IMember callingMember)
 		{
 			IMethodOrProperty methodOrProperty = callingMember as IMethodOrProperty;
@@ -1072,6 +1085,9 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				foreach (IParameter p in methodOrProperty.Parameters) {
 					result.Add(new DefaultField.ParameterField(p.ReturnType, p.Name, methodOrProperty.Region, callingClass));
 				}
+				if (callingMember is IMethod) {
+					AddTypeParametersForCtrlSpace(result, ((IMethod)callingMember).TypeParameters);
+				}
 			}
 			
 			bool inStatic = false;
@@ -1079,6 +1095,8 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
 				inStatic = callingMember.IsStatic;
 			
 			if (callingClass != null) {
+				AddTypeParametersForCtrlSpace(result, callingClass.TypeParameters);
+				
 				ArrayList members = new ArrayList();
 				IReturnType t = callingClass.DefaultReturnType;
 				members.AddRange(t.GetMethods());