Simplify ITypeReference interface; added missing implementations in DefaultTypeDefinition (GetNestedTypes, GetMethod, etc.).

ICSharpCode.NRefactory/TypeSystem/ConstructedType.cs

@@ -147,7 +147,23 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		public IList<IType> GetNestedTypes(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			/*
+			class Base<T> {
+				class Nested {}
+			}
+			class Derived<A, B> : Base<B> {}
+			
+			Derived<string,int>.GetNestedTypes() = { Base`1+Nested<int> }
+			Derived.GetNestedTypes() = { Base`1+Nested<B> }
+			Base<B>.GetNestedTypes() = { Base`1+Nested<B> }
+			Base.GetNestedTypes() = { Base`1+Nested<T2> } where T2 = copy of T in Base`1+Nested
+			 */
+			Substitution substitution = new Substitution(typeArguments);
+			IList<IType> types = genericType.GetNestedTypes(context);
+			for (int i = 0; i < types.Count; i++) {
+				types[i] = types[i].AcceptVisitor(substitution);
+			}
+			return types;
 		}
 		
 		public IList<IMethod> GetMethods(ITypeResolveContext context)

ICSharpCode.NRefactory/TypeSystem/EntityType.cs

@@ -7,6 +7,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 {
 	public enum EntityType : byte
 	{
+		None,
 		TypeDefinition,
 		Field,
 		Property,

ICSharpCode.NRefactory/TypeSystem/IField.cs

@@ -69,11 +69,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 		
 		string IVariable.Name {
-			get { throw new NotImplementedException();  }
+			get { return null;  }
 		}
 		
 		ITypeReference IVariable.Type {
-			get { throw new NotImplementedException(); }
+			get { return null; }
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IParameter.cs

@@ -85,14 +85,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 		
 		bool IFreezable.IsFrozen {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		void IFreezable.Freeze()
 		{
-			throw new NotImplementedException();
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/IType.cs

@@ -55,6 +55,45 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// by the return values of the visit calls.
 		/// </summary>
 		IType VisitChildren(TypeVisitor visitor);
+		
+		/// <summary>
+		/// Gets the direct base types.
+		/// </summary>
+		IEnumerable<IType> GetBaseTypes(ITypeResolveContext context);
+		
+		/// <summary>
+		/// Gets inner classes (including inherited inner classes).
+		/// </summary>
+		/// <remarks>
+		/// If the inner class is generic, this method produces <see cref="ConstructedType"/>s that
+		/// parameterize each nested class with its own type parameters.
+		/// </remarks>
+		/// <returns>A new mutable list</returns>
+		IList<IType> GetNestedTypes(ITypeResolveContext context);
+		
+		/// <summary>
+		/// Gets all methods that can be called on this return type.
+		/// </summary>
+		/// <returns>A new mutable list</returns>
+		IList<IMethod> GetMethods(ITypeResolveContext context);
+		
+		/// <summary>
+		/// Gets all properties that can be called on this return type.
+		/// </summary>
+		/// <returns>A new mutable list</returns>
+		IList<IProperty> GetProperties(ITypeResolveContext context);
+		
+		/// <summary>
+		/// Gets all fields that can be called on this return type.
+		/// </summary>
+		/// <returns>A new mutable list</returns>
+		IList<IField> GetFields(ITypeResolveContext context);
+		
+		/// <summary>
+		/// Gets all events that can be called on this return type.
+		/// </summary>
+		/// <returns>A new mutable list</returns>
+		IList<IEvent> GetEvents(ITypeResolveContext context);
 	}
 	
 	[ContractClassFor(typeof(IType))]
@@ -75,6 +114,48 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			get { return null; }
 		}
 		
+		IEnumerable<IType> IType.GetBaseTypes(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IEnumerable<IType>>() != null);
+			return null;
+		}
+		
+		IList<IType> IType.GetNestedTypes(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IType>>() != null);
+			return null;
+		}
+
+		IList<IMethod> IType.GetMethods(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IMethod>>() != null);
+			return null;
+		}
+		
+		IList<IProperty> IType.GetProperties(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IProperty>>() != null);
+			return null;
+		}
+		
+		IList<IField> IType.GetFields(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IField>>() != null);
+			return null;
+		}
+		
+		IList<IEvent> IType.GetEvents(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IEvent>>() != null);
+			return null;
+		}
+		
 		string INamedElement.FullName {
 			get {
 				Contract.Ensures(Contract.Result<string>() != null);

ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs

@@ -121,81 +121,63 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		
 		#region IEntity
 		EntityType IEntity.EntityType {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return EntityType.None; }
 		}
 		
 		DomRegion IEntity.Region {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return DomRegion.Empty; }
 		}
 		
 		DomRegion IEntity.BodyRegion {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return DomRegion.Empty; }
 		}
 		
 		ITypeDefinition IEntity.DeclaringTypeDefinition {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return null; }
 		}
 		
 		IList<IAttribute> IEntity.Attributes {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return null; }
 		}
 		
 		string IEntity.Documentation {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return null; }
 		}
 		
 		bool IEntity.IsStatic {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		Accessibility IEntity.Accessibility {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return Accessibility.None; }
 		}
 		
 		bool IEntity.IsAbstract {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		bool IEntity.IsSealed {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		bool IEntity.IsShadowing {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		bool IEntity.IsSynthetic {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return false; }
 		}
 		
 		IProjectContent IEntity.ProjectContent {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return null; }
+		}
+		
+		bool IFreezable.IsFrozen {
+			get { return false; }
+		}
+		
+		void IFreezable.Freeze()
+		{
 		}
 		#endregion
 	}

ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs

@@ -169,5 +169,13 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		VarianceModifier ITypeParameter.Variance {
 			get { return VarianceModifier.Invariant; }
 		}
+		
+		bool IFreezable.IsFrozen {
+			get { return false; }
+		}
+		
+		void IFreezable.Freeze()
+		{
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/ITypeReference.cs

@@ -7,51 +7,27 @@ using System.Diagnostics.Contracts;
 
 namespace ICSharpCode.NRefactory.TypeSystem
 {
+	/// <summary>
+	/// Represents a reference to a type.
+	/// Must be resolved before it can be used as type.
+	/// </summary>
 	[ContractClass(typeof(ITypeReferenceContract))]
-	public interface ITypeReference : IFreezable
+	public interface ITypeReference
 	{
-		/// <summary>
-		/// Resolves this type reference.
-		/// </summary>
-		IType Resolve(ITypeResolveContext context);
+		// Keep this interface simple: I decided against having GetMethods/GetEvents etc. here,
+		// so that the Resolve step is never hidden from the consumer.
 		
-		/// <summary>
-		/// Gets the direct base types.
-		/// </summary>
-		IEnumerable<IType> GetBaseTypes(ITypeResolveContext context);
+		// I decided against implementing IFreezable here: ITypeDefinition can be used as ITypeReference,
+		// but when freezing the reference, one wouldn't expect the definition to freeze.
 		
 		/// <summary>
-		/// Gets inner classes (including inherited inner classes).
-		/// </summary>
-		IList<IType> GetNestedTypes(ITypeResolveContext context);
-		
-		/// <summary>
-		/// Gets all methods that can be called on this return type.
-		/// </summary>
-		/// <returns>A new mutable list</returns>
-		IList<IMethod> GetMethods(ITypeResolveContext context);
-		
-		/// <summary>
-		/// Gets all properties that can be called on this return type.
-		/// </summary>
-		/// <returns>A new mutable list</returns>
-		IList<IProperty> GetProperties(ITypeResolveContext context);
-		
-		/// <summary>
-		/// Gets all fields that can be called on this return type.
-		/// </summary>
-		/// <returns>A new mutable list</returns>
-		IList<IField> GetFields(ITypeResolveContext context);
-		
-		/// <summary>
-		/// Gets all events that can be called on this return type.
+		/// Resolves this type reference.
 		/// </summary>
-		/// <returns>A new mutable list</returns>
-		IList<IEvent> GetEvents(ITypeResolveContext context);
+		IType Resolve(ITypeResolveContext context);
 	}
 	
 	[ContractClassFor(typeof(ITypeReference))]
-	abstract class ITypeReferenceContract : IFreezableContract, ITypeReference
+	abstract class ITypeReferenceContract : ITypeReference
 	{
 		IType ITypeReference.Resolve(ITypeResolveContext context)
 		{
@@ -59,47 +35,5 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Contract.Ensures(Contract.Result<IType>() != null);
 			return null;
 		}
-		
-		IEnumerable<IType> ITypeReference.GetBaseTypes(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IEnumerable<IType>>() != null);
-			return null;
-		}
-		
-		IList<IType> ITypeReference.GetNestedTypes(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IList<IType>>() != null);
-			return null;
-		}
-
-		IList<IMethod> ITypeReference.GetMethods(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IList<IMethod>>() != null);
-			return null;
-		}
-		
-		IList<IProperty> ITypeReference.GetProperties(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IList<IProperty>>() != null);
-			return null;
-		}
-		
-		IList<IField> ITypeReference.GetFields(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IList<IField>>() != null);
-			return null;
-		}
-		
-		IList<IEvent> ITypeReference.GetEvents(ITypeResolveContext context)
-		{
-			Contract.Requires(context != null);
-			Contract.Ensures(Contract.Result<IList<IEvent>>() != null);
-			return null;
-		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/ITypeResolveContext.cs

@@ -76,19 +76,19 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Contract.Requires(fullTypeName != null);
 			Contract.Requires(typeParameterCount >= 0);
 			Contract.Requires(nameComparer != null);
-			throw new NotImplementedException();
+			return null;
 		}
 		
 		ISynchronizedTypeResolveContext ITypeResolveContext.Synchronize()
 		{
 			Contract.Ensures(Contract.Result<ISynchronizedTypeResolveContext>() != null);
-			throw new NotImplementedException();
+			return null;
 		}
 		
 		IEnumerable<ITypeDefinition> ITypeResolveContext.GetClasses()
 		{
 			Contract.Ensures(Contract.Result<IEnumerable<ITypeDefinition>>() != null);
-			throw new NotImplementedException();
+			return null;
 		}
 		
 		IEnumerable<ITypeDefinition> ITypeResolveContext.GetClasses(string nameSpace, StringComparer nameComparer)
@@ -96,13 +96,13 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			Contract.Requires(nameSpace != null);
 			Contract.Requires(nameComparer != null);
 			Contract.Ensures(Contract.Result<IEnumerable<ITypeDefinition>>() != null);
-			throw new NotImplementedException();
+			return null;
 		}
 		
 		IEnumerable<string> ITypeResolveContext.GetNamespaces()
 		{
 			Contract.Ensures(Contract.Result<IEnumerable<ITypeDefinition>>() != null);
-			throw new NotImplementedException();
+			return null;
 		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractFreezable.cs

@@ -73,6 +73,14 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			else
 				return new ReadOnlyCollection<string>(list.ToArray());
 		}
+		
+		protected static IList<ITypeReference> FreezeList(IList<ITypeReference> list)
+		{
+			if (list == null || list.Count == 0)
+				return EmptyList<ITypeReference>.Instance;
+			else
+				return new ReadOnlyCollection<ITypeReference>(list.ToArray());
+		}
 	}
 	
 	static class EmptyList<T>

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractTypeReference.cs

@@ -6,38 +6,8 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 {
-	public abstract class AbstractTypeReference : Immutable, ITypeReference
+	public abstract class AbstractTypeReference : ITypeReference
 	{
 		public abstract IType Resolve(ITypeResolveContext context);
-		
-		public virtual IEnumerable<IType> GetBaseTypes(ITypeResolveContext context)
-		{
-			return Resolve(context).GetBaseTypes(context);
-		}
-		
-		public virtual IList<IType> GetNestedTypes(ITypeResolveContext context)
-		{
-			return Resolve(context).GetNestedTypes(context);
-		}
-
-		public virtual IList<IMethod> GetMethods(ITypeResolveContext context)
-		{
-			return Resolve(context).GetMethods(context);
-		}
-		
-		public virtual IList<IProperty> GetProperties(ITypeResolveContext context)
-		{
-			return Resolve(context).GetProperties(context);
-		}
-		
-		public virtual IList<IField> GetFields(ITypeResolveContext context)
-		{
-			return Resolve(context).GetFields(context);
-		}
-		
-		public virtual IList<IEvent> GetEvents(ITypeResolveContext context)
-		{
-			return Resolve(context).GetEvents(context);
-		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs

@@ -19,7 +19,6 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		protected override void FreezeInternal()
 		{
-			attributeType.Freeze();
 			positionalArguments = FreezeList(positionalArguments);
 			
 			if (namedArguments == null || namedArguments.Count == 0) {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultParameter.cs

@@ -47,7 +47,6 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		protected override void FreezeInternal()
 		{
-			type.Freeze();
 			attributes = FreezeList(attributes);
 			if (defaultValue != null)
 				defaultValue.Freeze();

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs

@@ -357,27 +357,83 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public IList<IType> GetNestedTypes(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			IList<IType> nestedTypes = null;
+			foreach (var baseTypeRef in this.BaseTypes) {
+				IType baseType = baseTypeRef.Resolve(context);
+				ITypeDefinition baseTypeDef = baseType.GetDefinition();
+				if (baseTypeDef != null && baseTypeDef.ClassType != ClassType.Interface) {
+					// get nested types from baseType (not baseTypeDef) so that generics work correctly
+					nestedTypes = baseType.GetNestedTypes(context);
+					break; // there is at most 1 non-interface base
+				}
+			}
+			if (nestedTypes == null)
+				nestedTypes = new List<IType>();
+			foreach (ITypeDefinition innerClass in this.InnerClasses) {
+				if (innerClass.TypeParameterCount > 0) {
+					// Parameterize inner classes with their own type parameters, as per <remarks> on IType.GetNestedTypes.
+					nestedTypes.Add(new ConstructedType(innerClass, innerClass.TypeParameters));
+				} else {
+					nestedTypes.Add(innerClass);
+				}
+			}
+			return nestedTypes;
 		}
 		
 		public IList<IMethod> GetMethods(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			List<IMethod> methods = new List<IMethod>();
+			foreach (var baseTypeRef in this.BaseTypes) {
+				IType baseType = baseTypeRef.Resolve(context);
+				ITypeDefinition baseTypeDef = baseType.GetDefinition();
+				if (baseTypeDef != null && (baseTypeDef.ClassType != ClassType.Interface || this.ClassType == ClassType.Interface)) {
+					methods.AddRange(baseType.GetMethods(context));
+				}
+			}
+			methods.AddRange(this.Methods);
+			return methods;
 		}
 		
 		public IList<IProperty> GetProperties(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			List<IProperty> properties = new List<IProperty>();
+			foreach (var baseTypeRef in this.BaseTypes) {
+				IType baseType = baseTypeRef.Resolve(context);
+				ITypeDefinition baseTypeDef = baseType.GetDefinition();
+				if (baseTypeDef != null && (baseTypeDef.ClassType != ClassType.Interface || this.ClassType == ClassType.Interface)) {
+					properties.AddRange(baseType.GetProperties(context));
+				}
+			}
+			properties.AddRange(this.Properties);
+			return properties;
 		}
 		
 		public IList<IField> GetFields(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			List<IField> fields = new List<IField>();
+			foreach (var baseTypeRef in this.BaseTypes) {
+				IType baseType = baseTypeRef.Resolve(context);
+				ITypeDefinition baseTypeDef = baseType.GetDefinition();
+				if (baseTypeDef != null && (baseTypeDef.ClassType != ClassType.Interface || this.ClassType == ClassType.Interface)) {
+					fields.AddRange(baseType.GetFields(context));
+				}
+			}
+			fields.AddRange(this.Fields);
+			return fields;
 		}
 		
 		public IList<IEvent> GetEvents(ITypeResolveContext context)
 		{
-			throw new NotImplementedException();
+			List<IEvent> events = new List<IEvent>();
+			foreach (var baseTypeRef in this.BaseTypes) {
+				IType baseType = baseTypeRef.Resolve(context);
+				ITypeDefinition baseTypeDef = baseType.GetDefinition();
+				if (baseTypeDef != null && (baseTypeDef.ClassType != ClassType.Interface || this.ClassType == ClassType.Interface)) {
+					events.AddRange(baseType.GetEvents(context));
+				}
+			}
+			events.AddRange(this.Events);
+			return events;
 		}
 		
 		public override bool Equals(object obj)

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMethod.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		/// <summary>
-		/// Performts type substitution in parameter types and in the return type.
+		/// Performs type substitution in parameter types and in the return type.
 		/// </summary>
 		public void SubstituteTypes(ITypeResolveContext context, TypeVisitor substitution)
 		{

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedProperty.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		/// <summary>
-		/// Performts type substitution in parameter types and in the return type.
+		/// Performs type substitution in parameter types and in the return type.
 		/// </summary>
 		public void SubstituteTypes(ITypeResolveContext context, TypeVisitor substitution)
 		{