Renamed ITypeDefinition.InnerClasses -> NestedTypes (for more

consistency with IType.GetNestedTypes

ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs

@@ -88,7 +88,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			ITypeDefinition type = GetTopLevelTypeDefinition(location);
 			while (type != null) {
 				parent = type;
-				type = FindEntity(parent.InnerClasses, location);
+				type = FindEntity(parent.NestedTypes, location);
 			}
 			return parent;
 		}

ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -127,7 +127,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			if (currentTypeDefinition != null) {
 				newType = new DefaultTypeDefinition(currentTypeDefinition, name);
 				newType.TypeParameters.AddRange(currentTypeDefinition.TypeParameters);
-				currentTypeDefinition.InnerClasses.Add(newType);
+				currentTypeDefinition.NestedTypes.Add(newType);
 			} else {
 				newType = new DefaultTypeDefinition(usingScope.ProjectContent, usingScope.NamespaceName, name);
 				parsedFile.TopLevelTypeDefinitions.Add(newType);

ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs

@@ -27,7 +27,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (type.DeclaringTypeDefinition != null) {
 				ITypeDefinition decl = type.DeclaringTypeDefinition.AcceptVisitor(this) as ITypeDefinition;
 				if (decl != null) {
-					foreach (ITypeDefinition c in decl.InnerClasses) {
+					foreach (ITypeDefinition c in decl.NestedTypes) {
 						if (c.Name == type.Name && c.TypeParameterCount == type.TypeParameterCount)
 							return c;
 					}

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -205,9 +205,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			try {
 				ITypeDefinition newTypeDefinition = null;
 				if (resolver.CurrentTypeDefinition != null) {
-					foreach (ITypeDefinition innerClass in resolver.CurrentTypeDefinition.InnerClasses) {
-						if (innerClass.Region.IsInside(typeDeclaration.StartLocation)) {
-							newTypeDefinition = innerClass;
+					foreach (ITypeDefinition nestedType in resolver.CurrentTypeDefinition.NestedTypes) {
+						if (nestedType.Region.IsInside(typeDeclaration.StartLocation)) {
+							newTypeDefinition = nestedType;
 							break;
 						}
 					}

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -746,11 +746,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 						if (name.Length == 0 || name[0] == '<')
 							continue;
 						name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name);
-						InnerClasses.Add(new CecilTypeDefinition(this, name, nestedType));
+						NestedTypes.Add(new CecilTypeDefinition(this, name, nestedType));
 					}
 				}
-				foreach (CecilTypeDefinition innerClass in this.InnerClasses) {
-					innerClass.Init(loader);
+				foreach (CecilTypeDefinition nestedType in this.NestedTypes) {
+					nestedType.Init(loader);
 				}
 			}
 			

ICSharpCode.NRefactory/TypeSystem/ExtensionMethods.cs

@@ -216,7 +216,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		public static IEnumerable<ITypeDefinition> GetAllClasses(this ITypeResolveContext context)
 		{
-			return TreeTraversal.PreOrder(context.GetClasses(), t => t.InnerClasses);
+			return TreeTraversal.PreOrder(context.GetClasses(), t => t.NestedTypes);
 		}
 		#endregion
 		

ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		IList<ITypeDefinition> GetParts();
 		
-		IList<ITypeDefinition> InnerClasses { get; }
+		IList<ITypeDefinition> NestedTypes { get; }
 		IList<IField> Fields { get; }
 		IList<IProperty> Properties { get; }
 		IList<IMethod> Methods { get; }

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs

@@ -21,7 +21,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		IList<ITypeReference> baseTypes;
 		IList<ITypeParameter> typeParameters;
-		IList<ITypeDefinition> innerClasses;
+		IList<ITypeDefinition> nestedTypes;
 		IList<IField> fields;
 		IList<IMethod> methods;
 		IList<IProperty> properties;
@@ -46,7 +46,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			baseTypes = FreezeList(baseTypes);
 			typeParameters = FreezeList(typeParameters);
-			innerClasses = FreezeList(innerClasses);
+			nestedTypes = FreezeList(nestedTypes);
 			fields = FreezeList(fields);
 			methods = FreezeList(methods);
 			properties = FreezeList(properties);
@@ -113,11 +113,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public IList<ITypeDefinition> InnerClasses {
+		public IList<ITypeDefinition> NestedTypes {
 			get {
-				if (innerClasses == null)
-					innerClasses = new List<ITypeDefinition>();
-				return innerClasses;
+				if (nestedTypes == null)
+					nestedTypes = new List<ITypeDefinition>();
+				return nestedTypes;
 			}
 		}
 		
@@ -404,9 +404,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 							break; // there is at most 1 non-interface base
 						}
 					}
-					foreach (ITypeDefinition innerClass in this.InnerClasses) {
-						if (filter == null || filter(innerClass)) {
-							nestedTypes.Add(innerClass);
+					foreach (ITypeDefinition nestedType in this.NestedTypes) {
+						if (filter == null || filter(nestedType)) {
+							nestedTypes.Add(nestedType);
 						}
 					}
 				}

ICSharpCode.NRefactory/TypeSystem/Implementation/NestedTypeReference.cs

@@ -40,7 +40,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			ITypeDefinition declaringType = declaringTypeRef.Resolve(context) as ITypeDefinition;
 			if (declaringType != null) {
 				int tpc = declaringType.TypeParameterCount;
-				foreach (IType type in declaringType.InnerClasses) {
+				foreach (IType type in declaringType.NestedTypes) {
 					if (type.Name == name && type.TypeParameterCount == tpc + additionalTypeParameterCount)
 						return type;
 				}

ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs

@@ -44,9 +44,9 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					int typeParameterCount;
 					string name = SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount);
 					typeParameterCount += declaringType.TypeParameterCount;
-					foreach (ITypeDefinition innerClass in declaringType.InnerClasses) {
-						if (innerClass.Name == name && innerClass.TypeParameterCount == typeParameterCount) {
-							return innerClass;
+					foreach (ITypeDefinition nestedType in declaringType.NestedTypes) {
+						if (nestedType.Name == name && nestedType.TypeParameterCount == typeParameterCount) {
+							return nestedType;
 						}
 					}
 				}