Renamed GetClass-> GetTypeDefinition;

ICSharpCode.NRefactory/CSharp/Analysis/MinimalResolveContext.cs

@@ -58,7 +58,7 @@ namespace ICSharpCode.NRefactory.CSharp.Analysis
 			};
 		}
 		
-		public ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
+		public ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
 		{
 			foreach (ITypeDefinition type in types) {
 				if (nameComparer.Equals(type.Name, name) && nameComparer.Equals(type.Namespace, nameSpace) && type.TypeParameterCount == typeParameterCount)

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -1586,7 +1586,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					}
 				}
 				// then look for a type
-				ITypeDefinition def = context.GetClass(n.NamespaceName, identifier, k, StringComparer.Ordinal);
+				ITypeDefinition def = context.GetTypeDefinition(n.NamespaceName, identifier, k, StringComparer.Ordinal);
 				if (def != null) {
 					IType result = def;
 					if (k != 0) {
@@ -1620,7 +1620,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					foreach (var u in n.Usings) {
 						NamespaceResolveResult ns = u.ResolveNamespace(context);
 						if (ns != null) {
-							def = context.GetClass(ns.NamespaceName, identifier, k, StringComparer.Ordinal);
+							def = context.GetTypeDefinition(ns.NamespaceName, identifier, k, StringComparer.Ordinal);
 							if (def != null) {
 								if (firstResult == null) {
 									if (k == 0)
@@ -1690,7 +1690,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					if (context.GetNamespace(fullName, StringComparer.Ordinal) != null)
 						return new NamespaceResolveResult(fullName);
 				}
-				ITypeDefinition def = context.GetClass(nrr.NamespaceName, identifier, typeArguments.Count, StringComparer.Ordinal);
+				ITypeDefinition def = context.GetTypeDefinition(nrr.NamespaceName, identifier, typeArguments.Count, StringComparer.Ordinal);
 				if (def != null)
 					return new TypeResolveResult(def);
 				return ErrorResult;

ICSharpCode.NRefactory/CSharp/Resolver/Conversions.cs

@@ -194,7 +194,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						|| ImplicitReferenceConversion(fromArray.ElementType, toPT.TypeArguments[0]);
 				}
 				// conversion from any array to System.Array and the interfaces it implements:
-				ITypeDefinition systemArray = context.GetClass("System", "Array", 0, StringComparer.Ordinal);
+				ITypeDefinition systemArray = context.GetTypeDefinition("System", "Array", 0, StringComparer.Ordinal);
 				return systemArray != null && (systemArray.Equals(toType) || ImplicitReferenceConversion(systemArray, toType));
 			}
 			

ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				return type;
 			} else {
-				return context.GetClass(type.Namespace, type.Name, type.TypeParameterCount, StringComparer.Ordinal) ?? type;
+				return context.GetTypeDefinition(type.Namespace, type.Name, type.TypeParameterCount, StringComparer.Ordinal) ?? type;
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/CecilLoader.cs

@@ -297,7 +297,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 					name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name, out typeParameterCount);
 					var earlyBindContext = this.EarlyBindContext;
 					if (earlyBindContext != null) {
-						IType c = earlyBindContext.GetClass(ns, name, typeParameterCount, StringComparer.Ordinal);
+						IType c = earlyBindContext.GetTypeDefinition(ns, name, typeParameterCount, StringComparer.Ordinal);
 						if (c != null)
 							return c;
 					}

ICSharpCode.NRefactory/TypeSystem/ITypeResolveContext.cs

@@ -18,18 +18,18 @@ namespace ICSharpCode.NRefactory.TypeSystem
 	public interface ITypeResolveContext
 	{
 		/// <summary>
-		/// Retrieves a class.
+		/// Retrieves a type.
 		/// </summary>
-		/// <param name="nameSpace">Namespace that contains the class</param>
-		/// <param name="name">Name of the class</param>
+		/// <param name="nameSpace">Namespace that contains the type</param>
+		/// <param name="name">Name of the type</param>
 		/// <param name="typeParameterCount">Number of type parameters</param>
 		/// <param name="nameComparer">Language-specific rules for how class names are compared</param>
-		/// <returns>The type definition for the class; or null if no such class exists.</returns>
-		/// <remarks>This method never returns inner classes; it can be used only with top-level classes.</remarks>
-		ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer);
+		/// <returns>The type definition for the class; or null if no such type exists.</returns>
+		/// <remarks>This method never returns inner types; it can be used only with top-level types.</remarks>
+		ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer);
 		
 		/// <summary>
-		/// Retrieves all top-level classes.
+		/// Retrieves all top-level types.
 		/// </summary>
 		/// <remarks>
 		/// If this method is called within <c>using (pc.Synchronize())</c>, then the returned enumerable is valid
@@ -38,11 +38,11 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		IEnumerable<ITypeDefinition> GetTypes();
 		
 		/// <summary>
-		/// Retrieves all classes in the specified namespace.
+		/// Retrieves all types in the specified namespace.
 		/// </summary>
-		/// <param name="nameSpace">Namespace in which classes are being retrieved. Use <c>string.Empty</c> for the root namespace.</param>
+		/// <param name="nameSpace">Namespace in which types are being retrieved. Use <c>string.Empty</c> for the root namespace.</param>
 		/// <param name="nameComparer">Language-specific rules for how namespace names are compared</param>
-		/// <returns>List of classes within that namespace.</returns>
+		/// <returns>List of types within that namespace.</returns>
 		/// <remarks>
 		/// If this method is called within <c>using (var spc = pc.Synchronize())</c>, then the returned enumerable is valid
 		/// only until the end of the synchronize block.

ICSharpCode.NRefactory/TypeSystem/Implementation/CompositeTypeResolveContext.cs

@@ -52,10 +52,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		/// <inheritdoc/>
-		public ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
+		public ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
 		{
 			foreach (ITypeResolveContext context in children) {
-				ITypeDefinition d = context.GetClass(nameSpace, name, typeParameterCount, nameComparer);
+				ITypeDefinition d = context.GetTypeDefinition(nameSpace, name, typeParameterCount, nameComparer);
 				if (d != null)
 					return d;
 			}

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs

@@ -235,7 +235,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public IEnumerable<IMethod> GetMethods(ITypeResolveContext context, Predicate<IMethod> filter = null)
 		{
 			// TODO: get methods from constraints
-			IType objectType = context.GetClass("System", "Object", 0, StringComparer.Ordinal);
+			IType objectType = context.GetTypeDefinition("System", "Object", 0, StringComparer.Ordinal);
 			IEnumerable<IMethod> objectMethods;
 			if (objectType != null)
 				objectMethods = objectType.GetMethods(context, filter);
@@ -268,7 +268,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public IEnumerable<IType> GetBaseTypes(ITypeResolveContext context)
 		{
-			IType defaultBaseType = context.GetClass("System", HasValueTypeConstraint ? "ValueType" : "Object", 0, StringComparer.Ordinal);
+			IType defaultBaseType = context.GetTypeDefinition("System", HasValueTypeConstraint ? "ValueType" : "Object", 0, StringComparer.Ordinal);
 			if (defaultBaseType != null)
 				yield return defaultBaseType;
 			

ICSharpCode.NRefactory/TypeSystem/Implementation/GetClassTypeReference.cs

@@ -83,7 +83,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		IType DoResolve(ITypeResolveContext context)
 		{
 			 */
-			return context.GetClass(nameSpace, name, typeParameterCount, StringComparer.Ordinal) ?? SharedTypes.UnknownType;
+			return context.GetTypeDefinition(nameSpace, name, typeParameterCount, StringComparer.Ordinal) ?? SharedTypes.UnknownType;
 		}
 		
 		public override string ToString()

ICSharpCode.NRefactory/TypeSystem/Implementation/ProxyTypeResolveContext.cs

@@ -25,9 +25,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		}
 		
 		/// <inheritdoc/>
-		public virtual ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
+		public virtual ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
 		{
-			return target.GetClass(nameSpace, name, typeParameterCount, nameComparer);
+			return target.GetTypeDefinition(nameSpace, name, typeParameterCount, nameComparer);
 		}
 		
 		/// <inheritdoc/>

ICSharpCode.NRefactory/TypeSystem/Implementation/SimpleProjectContent.cs

@@ -118,11 +118,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		#endregion
 		
 		#region IProjectContent implementation
-		public ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
+		public ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
 		{
 			readerWriterLock.EnterReadLock();
 			try {
-				return types.GetClass(nameSpace, name, typeParameterCount, nameComparer);
+				return types.GetTypeDefinition(nameSpace, name, typeParameterCount, nameComparer);
 			} finally {
 				readerWriterLock.ExitReadLock();
 			}

ICSharpCode.NRefactory/TypeSystem/Implementation/TypeStorage.cs

@@ -203,7 +203,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		#region ITypeResolveContext implementation
 		/// <inheritdoc/>
-		public ITypeDefinition GetClass(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
+		public ITypeDefinition GetTypeDefinition(string nameSpace, string name, int typeParameterCount, StringComparer nameComparer)
 		{
 			if (nameSpace == null)
 				throw new ArgumentNullException("nameSpace");

ICSharpCode.NRefactory/TypeSystem/NullableType.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			if (context == null)
 				throw new ArgumentNullException("context");
 			
-			ITypeDefinition nullable = context.GetClass("System", "Nullable", 1, StringComparer.Ordinal);
+			ITypeDefinition nullable = context.GetTypeDefinition("System", "Nullable", 1, StringComparer.Ordinal);
 			if (nullable != null)
 				return new ParameterizedType(nullable, new [] { elementType });
 			else

ICSharpCode.NRefactory/TypeSystem/ReflectionHelper.cs

@@ -54,7 +54,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			} else {
 				int typeParameterCount;
 				string name = SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount);
-				return context.GetClass(type.Namespace, name, typeParameterCount, StringComparer.Ordinal);
+				return context.GetTypeDefinition(type.Namespace, name, typeParameterCount, StringComparer.Ordinal);
 			}
 		}
 		#endregion