Added IsSpecialized to IMember & IsParameterized to IType to make it

easier to handle such cases without asking for the type of the
objects.

ICSharpCode.NRefactory/TypeSystem/IMember.cs

@@ -179,5 +179,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			get;
 		}
 
+		/// <summary>
+		/// If true a type substitution on this member has been performed.
+		/// </summary>
+		bool IsSpecialized {
+			get;
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IType.cs

@@ -96,6 +96,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		IList<IType> TypeArguments { get; }
 
+		/// <summary>
+		/// If true the type represents an instance of a generic type.
+		/// </summary>
+		bool IsParameterized { get; }
+
 		/// <summary>
 		/// Calls ITypeVisitor.Visit for this type.
 		/// </summary>

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -122,6 +122,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return TypeParameterSubstitution.Identity; }
 		}
 
+		public bool IsSpecialized {
+			get { return false; }
+		}
+
 		public virtual IMemberReference ToMemberReference()
 		{
 			var declTypeRef = this.DeclaringType.ToTypeReference();

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedTypeParameter.cs

@@ -207,6 +207,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return 0; }
 		}
 
+		bool IType.IsParameterized { 
+			get { return false; }
+		}
+
 		readonly static IList<ITypeParameter> emptyTypeParameters = new ITypeParameter[0];
 		IList<ITypeParameter> IType.TypeParameters {
 			get { return emptyTypeParameters; }

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractType.cs

@@ -65,14 +65,18 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 
 		readonly static IList<IType> emptyTypeArguments = new IType[0];
-		IList<IType> IType.TypeArguments {
+		public virtual IList<IType> TypeArguments {
 			get { return emptyTypeArguments; }
 		}
 
 		public virtual IType DeclaringType {
 			get { return null; }
 		}
-		
+
+		public virtual bool IsParameterized { 
+			get { return false; }
+		}
+
 		public virtual ITypeDefinition GetDefinition()
 		{
 			return null;

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -494,10 +494,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 
 		readonly static IList<IType> emptyTypeArguments = new IType[0];
-		IList<IType> IType.TypeArguments {
+		public IList<IType> TypeArguments {
 			get { return emptyTypeArguments; }
 		}
 
+		public bool IsParameterized { 
+			get { return false; }
+		}
+
 		#region DirectBaseTypes
 		IList<IType> directBaseTypes;
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -301,7 +301,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public IAssembly ParentAssembly {
 			get { return baseMember.ParentAssembly; }
 		}
-		
+
+		public bool IsSpecialized {
+			get { return true; }
+		}
+
 		public override bool Equals(object obj)
 		{
 			SpecializedMember other = obj as SpecializedMember;

ICSharpCode.NRefactory/TypeSystem/ParameterizedType.cs

@@ -147,6 +147,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 
+		public bool IsParameterized { 
+			get {
+				return true;
+			}
+		}
+
 		/// <summary>
 		/// Same as 'parameterizedType.TypeArguments[index]', but is a bit more efficient (doesn't require the read-only wrapper).
 		/// </summary>