Fixed some bugs related to conversions of type parameters.

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConversionsTest.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
 using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.CSharp.Resolver
@@ -16,13 +17,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	[TestFixture]
 	public unsafe class ConversionsTest
 	{
-		IProjectContent mscorlib = CecilLoaderTests.Mscorlib;
+		ITypeResolveContext ctx = CecilLoaderTests.Mscorlib;
 		Conversions conversions = new Conversions(CecilLoaderTests.Mscorlib);
 		
 		bool ImplicitConversion(Type from, Type to)
 		{
-			IType from2 = from.ToTypeReference().Resolve(mscorlib);
-			IType to2 = to.ToTypeReference().Resolve(mscorlib);
+			IType from2 = from.ToTypeReference().Resolve(ctx);
+			IType to2 = to.ToTypeReference().Resolve(ctx);
 			return conversions.ImplicitConversion(from2, to2);
 		}
 		
@@ -194,11 +195,77 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			Assert.IsFalse(ImplicitConversion(typeof(int*), typeof(dynamic)));
 		}
 		
-		[Test, Ignore]
-		public void TypeParameterConversions()
+		[Test]
+		public void UnconstrainedTypeParameter()
+		{
+			DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T");
+			DefaultTypeParameter t2 = new DefaultTypeParameter(EntityType.TypeDefinition, 1, "T2");
+			DefaultTypeParameter tm = new DefaultTypeParameter(EntityType.Method, 0, "TM");
+			
+			Assert.IsFalse(conversions.ImplicitConversion(SharedTypes.Null, t));
+			Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic));
+			Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType))));
+			
+			Assert.IsTrue(conversions.ImplicitConversion(t, t));
+			Assert.IsFalse(conversions.ImplicitConversion(t2, t));
+			Assert.IsFalse(conversions.ImplicitConversion(t, t2));
+			Assert.IsFalse(conversions.ImplicitConversion(t, tm));
+			Assert.IsFalse(conversions.ImplicitConversion(tm, t));
+		}
+		
+		[Test]
+		public void TypeParameterWithReferenceTypeConstraint()
+		{
+			DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T");
+			t.HasReferenceTypeConstraint = true;
+			
+			Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.Null, t));
+			Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic));
+			Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType))));
+		}
+		
+		[Test]
+		public void TypeParameterWithValueTypeConstraint()
 		{
-			// TODO: write tests for conversions of type parameters
-			throw new NotImplementedException();
+			DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T");
+			t.HasValueTypeConstraint = true;
+			
+			Assert.IsFalse(conversions.ImplicitConversion(SharedTypes.Null, t));
+			Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic));
+			Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType))));
+		}
+		
+		[Test]
+		public void TypeParameterWithClassConstraint()
+		{
+			DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T");
+			t.Constraints.Add(ctx.GetTypeDefinition(typeof(StringComparer)));
+			
+			Assert.IsTrue(conversions.ImplicitConversion(SharedTypes.Null, t));
+			Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic));
+			Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType))));
+			Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(StringComparer))));
+			Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IComparer))));
+			Assert.IsFalse(conversions.ImplicitConversion(t, typeof(IComparer<int>).ToTypeReference().Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, typeof(IComparer<string>).ToTypeReference().Resolve(ctx)));
+		}
+		
+		[Test]
+		public void TypeParameterWithInterfaceConstraint()
+		{
+			DefaultTypeParameter t = new DefaultTypeParameter(EntityType.TypeDefinition, 0, "T");
+			t.Constraints.Add(ctx.GetTypeDefinition(typeof(IList)));
+			
+			Assert.IsFalse(conversions.ImplicitConversion(SharedTypes.Null, t));
+			Assert.IsTrue(conversions.ImplicitConversion(t, KnownTypeReference.Object.Resolve(ctx)));
+			Assert.IsTrue(conversions.ImplicitConversion(t, SharedTypes.Dynamic));
+			Assert.IsFalse(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(ValueType))));
+			Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IList))));
+			Assert.IsTrue(conversions.ImplicitConversion(t, ctx.GetTypeDefinition(typeof(IEnumerable))));
 		}
 		
 		[Test]
@@ -221,9 +288,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		bool IntegerLiteralConversion(object value, Type to)
 		{
-			IType fromType = value.GetType().ToTypeReference().Resolve(mscorlib);
+			IType fromType = value.GetType().ToTypeReference().Resolve(ctx);
 			ConstantResolveResult crr = new ConstantResolveResult(fromType, value);
-			IType to2 = to.ToTypeReference().Resolve(mscorlib);
+			IType to2 = to.ToTypeReference().Resolve(ctx);
 			return conversions.ImplicitConversion(crr, to2);
 		}
 		
@@ -298,18 +365,18 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		int BetterConversion(Type s, Type t1, Type t2)
 		{
-			IType sType = s.ToTypeReference().Resolve(mscorlib);
-			IType t1Type = t1.ToTypeReference().Resolve(mscorlib);
-			IType t2Type = t2.ToTypeReference().Resolve(mscorlib);
+			IType sType = s.ToTypeReference().Resolve(ctx);
+			IType t1Type = t1.ToTypeReference().Resolve(ctx);
+			IType t2Type = t2.ToTypeReference().Resolve(ctx);
 			return conversions.BetterConversion(sType, t1Type, t2Type);
 		}
 		
 		int BetterConversion(object value, Type t1, Type t2)
 		{
-			IType fromType = value.GetType().ToTypeReference().Resolve(mscorlib);
+			IType fromType = value.GetType().ToTypeReference().Resolve(ctx);
 			ConstantResolveResult crr = new ConstantResolveResult(fromType, value);
-			IType t1Type = t1.ToTypeReference().Resolve(mscorlib);
-			IType t2Type = t2.ToTypeReference().Resolve(mscorlib);
+			IType t1Type = t1.ToTypeReference().Resolve(ctx);
+			IType t2Type = t2.ToTypeReference().Resolve(ctx);
 			return conversions.BetterConversion(crr, t1Type, t2Type);
 		}
 		

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs

@@ -211,7 +211,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			var e = testCasePC.GetTypeDefinition(typeof(MyEnum));
 			Assert.AreEqual(ClassType.Enum, e.ClassType);
-			Assert.AreEqual(false, e.IsReferenceType);
+			Assert.AreEqual(false, e.IsReferenceType(ctx));
 			Assert.AreEqual("System.Int16", e.BaseTypes[0].Resolve(ctx).ReflectionName);
 			Assert.AreEqual(new[] { "System.Enum" }, e.GetBaseTypes(ctx).Select(t => t.ReflectionName).ToArray());
 		}

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2010 AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// Copyright (c) 2010 AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 // This code is distributed under MIT X11 license (for details please see \doc\license.txt)
 
 using System;
@@ -649,8 +649,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			// TODO: find user-defined operators
 			
-			if (lhsType == SharedTypes.Null && rhsType.IsReferenceType == false
-			    || lhsType.IsReferenceType == false && rhsType == SharedTypes.Null)
+			if (lhsType == SharedTypes.Null && rhsType.IsReferenceType(context) == false
+			    || lhsType.IsReferenceType(context) == false && rhsType == SharedTypes.Null)
 			{
 				isNullable = true;
 			}

ICSharpCode.NRefactory/CSharp/Resolver/Conversions.cs

@@ -65,6 +65,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return true;
 			if (ImplicitDynamicConversion(fromType, toType))
 				return true;
+			if (ImplicitTypeParameterConversion(fromType, toType))
+				return true;
 			if (ImplicitPointerConversion(fromType, toType))
 				return true;
 			if (ImplicitUserDefinedConversion(fromType, toType))
@@ -87,6 +89,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return true;
 			if (ImplicitReferenceConversion(fromType, toType))
 				return true;
+			if (ImplicitTypeParameterConversion(fromType, toType))
+				return true;
 			if (BoxingConversion(fromType, toType))
 				return true;
 			return false;
@@ -199,7 +203,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			// C# 4.0 spec: §6.1.6
 			
 			// reference conversions are possible only if both types are known to be reference types
-			if (fromType.IsReferenceType != true || toType.IsReferenceType != true)
+			if (!(fromType.IsReferenceType(context) == true && toType.IsReferenceType(context) == true))
 				return false;
 			
 			// conversion from null literal is always possible
@@ -234,7 +238,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		
 		// Determines whether s is a subtype of t.
-		// Helper method used for ImplicitReferenceConversion and BoxingConversion
+		// Helper method used for ImplicitReferenceConversion, BoxingConversion and ImplicitTypeParameterConversion
 		bool IsSubtypeOf(IType s, IType t)
 		{
 			// conversion to dynamic + object are always possible
@@ -293,7 +297,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			// C# 4.0 spec: §6.1.7
 			fromType = NullableType.GetUnderlyingType(fromType);
-			return fromType.IsReferenceType == false && toType.IsReferenceType == true && IsSubtypeOf(fromType, toType);
+			return fromType.IsReferenceType(context) == false && toType.IsReferenceType(context) == true && IsSubtypeOf(fromType, toType);
 		}
 		#endregion
 		
@@ -335,6 +339,21 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
+		#region ImplicitTypeParameterConversion
+		/// <summary>
+		/// Implicit conversions involving type parameters.
+		/// </summary>
+		bool ImplicitTypeParameterConversion(IType fromType, IType toType)
+		{
+			ITypeParameter t = fromType as ITypeParameter;
+			if (t == null)
+				return false; // not a type parameter
+			if (t.IsReferenceType(context) == true)
+				return false; // already handled by ImplicitReferenceConversion
+			return IsSubtypeOf(t, toType);
+		}
+		#endregion
+		
 		#region ImplicitPointerConversion
 		bool ImplicitPointerConversion(IType fromType, IType toType)
 		{
@@ -367,7 +386,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					return true;
 				}
 				// Try if the operator is applicable in lifted form:
-				if (sourceType.IsReferenceType == false && targetType.IsReferenceType == false) {
+				if (sourceType.IsReferenceType(context) == false && targetType.IsReferenceType(context) == false) {
 					IType liftedSourceType = NullableType.Create(sourceType, context);
 					IType liftedTargetType = NullableType.Create(targetType, context);
 					if (StandardImplicitConversion(fromType, liftedSourceType) && StandardImplicitConversion(liftedTargetType, toType)) {

ICSharpCode.NRefactory/CSharp/Resolver/OverloadResolution.cs

@@ -259,11 +259,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 							ITypeParameter tp = typeParameters[i];
 							IType typeArg = newParameterizedType.TypeArguments[i];
 							if (tp.HasReferenceTypeConstraint) {
-								if (typeArg.IsReferenceType != true)
+								if (typeArg.IsReferenceType(overloadResolution.context) != true)
 									ConstraintsValid = false;
 							}
 							if (tp.HasValueTypeConstraint) {
-								if (typeArg.IsReferenceType != false)
+								if (typeArg.IsReferenceType(overloadResolution.context) != false)
 									ConstraintsValid = false;
 								if (NullableType.IsNullable(typeArg))
 									ConstraintsValid = false;

ICSharpCode.NRefactory/CSharp/Resolver/TypeInference.cs

@@ -535,7 +535,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					for (int i = 0; i < uniqueBaseType.TypeParameterCount; i++) {
 						IType Ui = uniqueBaseType.TypeArguments[i];
 						IType Vi = pV.TypeArguments[i];
-						if (Ui.IsReferenceType == true) {
+						if (Ui.IsReferenceType(context) == true) {
 							// look for variance
 							ITypeParameter Xi = pV.GetDefinition().TypeParameters[i];
 							switch (Xi.Variance) {
@@ -619,7 +619,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					for (int i = 0; i < uniqueBaseType.TypeParameterCount; i++) {
 						IType Ui = pU.TypeArguments[i];
 						IType Vi = uniqueBaseType.TypeArguments[i];
-						if (Ui.IsReferenceType == true) {
+						if (Ui.IsReferenceType(context) == true) {
 							// look for variance
 							ITypeParameter Xi = pU.GetDefinition().TypeParameters[i];
 							switch (Xi.Variance) {
@@ -692,8 +692,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return "X"; }
 			}
 			
-			public override bool? IsReferenceType {
-				get { return null; }
+			public override bool? IsReferenceType(ITypeResolveContext context)
+			{
+				return null;
 			}
 			
 			public override int GetHashCode()

ICSharpCode.NRefactory/TypeSystem/ArrayType.cs

@@ -31,8 +31,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		public override Nullable<bool> IsReferenceType {
-			get { return true; }
+		public override bool? IsReferenceType(ITypeResolveContext context)
+		{
+			return true;
 		}
 		
 		public override int GetHashCode()

ICSharpCode.NRefactory/TypeSystem/ByReferenceType.cs

@@ -16,8 +16,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		public override Nullable<bool> IsReferenceType {
-			get { return null; }
+		public override bool? IsReferenceType(ITypeResolveContext context)
+		{
+			return null;
 		}
 		
 		public override int GetHashCode()

ICSharpCode.NRefactory/TypeSystem/IType.cs

@@ -20,7 +20,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// false, if the type is a value type.
 		/// null, if the type is not known (e.g. unconstrained generic type parameter or type not found)
 		/// </returns>
-		bool? IsReferenceType { get; }
+		/// <remarks>
+		/// The resolve context is required for type parameters with a constraint "T : SomeType":
+		/// the type parameter is a reference type iff SomeType is a class type.
+		/// </remarks>
+		bool? IsReferenceType(ITypeResolveContext context);
 		
 		/// <summary>
 		/// Gets the underlying type definition.
@@ -102,8 +106,10 @@ namespace ICSharpCode.NRefactory.TypeSystem
 	[ContractClassFor(typeof(IType))]
 	abstract class ITypeContract : ITypeReferenceContract, IType
 	{
-		Nullable<bool> IType.IsReferenceType {
-			get { return null; }
+		bool? IType.IsReferenceType(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			return null;
 		}
 		
 		int IType.TypeParameterCount {

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractType.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return this.FullName; }
 		}
 		
-		public abstract bool? IsReferenceType { get; }
+		public abstract bool? IsReferenceType(ITypeResolveContext context);
 		
 		public virtual int TypeParameterCount {
 			get { return 0; }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs

@@ -162,19 +162,18 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public bool? IsReferenceType {
-			get {
-				switch (this.ClassType) {
-					case ClassType.Class:
-					case ClassType.Interface:
-					case ClassType.Delegate:
-						return true;
-					case ClassType.Enum:
-					case ClassType.Struct:
-						return false;
-					default:
-						return null;
-				}
+		public bool? IsReferenceType(ITypeResolveContext context)
+		{
+			switch (this.ClassType) {
+				case ClassType.Class:
+				case ClassType.Interface:
+				case ClassType.Delegate:
+					return true;
+				case ClassType.Enum:
+				case ClassType.Struct:
+					return false;
+				default:
+					return null;
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs

@@ -71,17 +71,33 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public bool? IsReferenceType {
-			get {
-				switch (flags.Data & (FlagReferenceTypeConstraint | FlagValueTypeConstraint)) {
-					case FlagReferenceTypeConstraint:
-						return true;
-					case FlagValueTypeConstraint:
-						return false;
-					default:
-						return null;
+		public bool? IsReferenceType(ITypeResolveContext context)
+		{
+			switch (flags.Data & (FlagReferenceTypeConstraint | FlagValueTypeConstraint)) {
+				case FlagReferenceTypeConstraint:
+					return true;
+				case FlagValueTypeConstraint:
+					return false;
+			}
+			// protect against cyclic dependencies between type parameters
+			using (var busyLock = BusyManager.Enter(this)) {
+				if (busyLock.Success) {
+					foreach (ITypeReference constraintRef in this.Constraints) {
+						IType constraint = constraintRef.Resolve(context);
+						ITypeDefinition constraintDef = constraint.GetDefinition();
+						// While interfaces are reference types, an interface constraint does not
+						// force the type parameter to be a reference type; so we need to explicitly look for classes here.
+						if (constraintDef != null && constraintDef.ClassType == ClassType.Class)
+							return true;
+						if (constraint is ITypeParameter) {
+							bool? isReferenceType = constraint.IsReferenceType(context);
+							if (isReferenceType.HasValue)
+								return isReferenceType.Value;
+						}
+					}
 				}
 			}
+			return null;
 		}
 		
 		int IType.TypeParameterCount {
@@ -277,12 +293,19 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public IEnumerable<IType> GetBaseTypes(ITypeResolveContext context)
 		{
-			IType defaultBaseType = context.GetTypeDefinition("System", HasValueTypeConstraint ? "ValueType" : "Object", 0, StringComparer.Ordinal);
-			if (defaultBaseType != null)
-				yield return defaultBaseType;
-			
+			bool hasNonInterfaceConstraint = false;
 			foreach (ITypeReference constraint in this.Constraints) {
-				yield return constraint.Resolve(context);
+				IType c = constraint.Resolve(context);
+				yield return c;
+				ITypeDefinition cdef = c.GetDefinition();
+				if (!(cdef != null && cdef.ClassType == ClassType.Interface))
+					hasNonInterfaceConstraint = true;
+			}
+			// Do not add the 'System.Object' constraint if there is another constraint with a base class.
+			if (HasValueTypeConstraint || !hasNonInterfaceConstraint) {
+				IType defaultBaseType = context.GetTypeDefinition("System", HasValueTypeConstraint ? "ValueType" : "Object", 0, StringComparer.Ordinal);
+				if (defaultBaseType != null)
+					yield return defaultBaseType;
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/IntersectionType.cs

@@ -63,8 +63,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		public override Nullable<bool> IsReferenceType {
-			get { return null; }
+		public override bool? IsReferenceType(ITypeResolveContext context)
+		{
+			foreach (var t in types) {
+				bool? isReferenceType = t.IsReferenceType(context);
+				if (isReferenceType.HasValue)
+					return isReferenceType.Value;
+			}
+			return null;
 		}
 		
 		public override int GetHashCode()

ICSharpCode.NRefactory/TypeSystem/ParameterizedType.cs

@@ -78,8 +78,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			this.typeArguments = typeArguments;
 		}
 		
-		public bool? IsReferenceType {
-			get { return genericType.IsReferenceType; }
+		public bool? IsReferenceType(ITypeResolveContext context)
+		{
+			return genericType.IsReferenceType(context);
 		}
 		
 		public IType DeclaringType {

ICSharpCode.NRefactory/TypeSystem/PointerType.cs

@@ -18,8 +18,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		public override Nullable<bool> IsReferenceType {
-			get { return null; }
+		public override bool? IsReferenceType(ITypeResolveContext context)
+		{
+			return null;
 		}
 		
 		public override int GetHashCode()

ICSharpCode.NRefactory/TypeSystem/SharedTypes.cs

@@ -57,8 +57,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				get { return "?"; }
 			}
 			
-			public override bool? IsReferenceType {
-				get { return null; }
+			public override bool? IsReferenceType(ITypeResolveContext context)
+			{
+				return null;
 			}
 			
 			public override bool Equals(IType other)
@@ -81,8 +82,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				get { return "null"; }
 			}
 			
-			public override bool? IsReferenceType {
-				get { return true; }
+			public override bool? IsReferenceType(ITypeResolveContext context)
+			{
+				return true;
 			}
 			
 			public override bool Equals(IType other)
@@ -105,8 +107,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 				get { return "dynamic"; }
 			}
 			
-			public override bool? IsReferenceType {
-				get { return true; }
+			public override bool? IsReferenceType(ITypeResolveContext context)
+			{
+				return true;
 			}
 			
 			public override bool Equals(IType other)