Rename Conversions to CSharpConversions.

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -270,7 +270,7 @@
     <Compile Include="Refactoring\Script.cs" />
     <Compile Include="Refactoring\TypeSystemAstBuilder.cs" />
     <Compile Include="Resolver\CompositeResolveVisitorNavigator.cs" />
-    <Compile Include="Resolver\Conversions.cs" />
+    <Compile Include="Resolver\CSharpConversions.cs" />
     <Compile Include="Resolver\CSharpAstResolver.cs" />
     <Compile Include="Resolver\CSharpInvocationResolveResult.cs" />
     <Compile Include="Resolver\CSharpOperators.cs" />

ICSharpCode.NRefactory.CSharp/Resolver/CSharpConversions.cs

@@ -34,13 +34,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	/// <remarks>
 	/// This class is thread-safe.
 	/// </remarks>
-	public sealed class Conversions
+	public sealed class CSharpConversions
 	{
 		readonly ConcurrentDictionary<TypePair, Conversion> implicitConversionCache = new ConcurrentDictionary<TypePair, Conversion>();
 		readonly ICompilation compilation;
 		readonly IType objectType;
 		
-		public Conversions(ICompilation compilation)
+		public CSharpConversions(ICompilation compilation)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
@@ -53,14 +53,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Gets the Conversions instance for the specified <see cref="ICompilation"/>.
 		/// This will make use of the context's cache manager to reuse the Conversions instance.
 		/// </summary>
-		public static Conversions Get(ICompilation compilation)
+		public static CSharpConversions Get(ICompilation compilation)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			CacheManager cache = compilation.CacheManager;
-			Conversions operators = (Conversions)cache.GetShared(typeof(Conversions));
+			CSharpConversions operators = (CSharpConversions)cache.GetShared(typeof(CSharpConversions));
 			if (operators == null) {
-				operators = (Conversions)cache.GetOrAddShared(typeof(Conversions), new Conversions(compilation));
+				operators = (CSharpConversions)cache.GetOrAddShared(typeof(CSharpConversions), new CSharpConversions(compilation));
 			}
 			return operators;
 		}
@@ -267,7 +267,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			readonly IType objectType;
 			
-			public DynamicErasure(Conversions conversions)
+			public DynamicErasure(CSharpConversions conversions)
 			{
 				this.objectType = conversions.objectType;
 			}

ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs

@@ -45,7 +45,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		static readonly ResolveResult NullResult = new ResolveResult(SpecialType.NullType);
 		
 		readonly ICompilation compilation;
-		internal readonly Conversions conversions;
+		internal readonly CSharpConversions conversions;
 		readonly CSharpTypeResolveContext context;
 		readonly bool checkForOverflow;
 		readonly bool isWithinLambdaExpression;
@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			this.compilation = compilation;
-			this.conversions = Conversions.Get(compilation);
+			this.conversions = CSharpConversions.Get(compilation);
 			this.context = new CSharpTypeResolveContext(compilation.MainAssembly);
 		}
 		
@@ -65,13 +65,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (context == null)
 				throw new ArgumentNullException("context");
 			this.compilation = context.Compilation;
-			this.conversions = Conversions.Get(compilation);
+			this.conversions = CSharpConversions.Get(compilation);
 			this.context = context;
 			if (context.CurrentTypeDefinition != null)
 				currentTypeDefinitionCache = new TypeDefinitionCache(context.CurrentTypeDefinition);
 		}
 		
-		private CSharpResolver(ICompilation compilation, Conversions conversions, CSharpTypeResolveContext context, bool checkForOverflow, bool isWithinLambdaExpression, TypeDefinitionCache currentTypeDefinitionCache, ImmutableStack<IVariable> localVariableStack, ObjectInitializerContext objectInitializerStack)
+		private CSharpResolver(ICompilation compilation, CSharpConversions conversions, CSharpTypeResolveContext context, bool checkForOverflow, bool isWithinLambdaExpression, TypeDefinitionCache currentTypeDefinitionCache, ImmutableStack<IVariable> localVariableStack, ObjectInitializerContext objectInitializerStack)
 		{
 			this.compilation = compilation;
 			this.conversions = conversions;
@@ -1732,7 +1732,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return IsEligibleExtensionMethod(compilation, conversions, targetType, method, useTypeInference, out outInferredTypes);
 		}
 		
-		internal static bool IsEligibleExtensionMethod(ICompilation compilation, Conversions conversions, IType targetType, IMethod method, bool useTypeInference, out IType[] outInferredTypes)
+		internal static bool IsEligibleExtensionMethod(ICompilation compilation, CSharpConversions conversions, IType targetType, IMethod method, bool useTypeInference, out IType[] outInferredTypes)
 		{
 			outInferredTypes = null;
 			if (targetType == null)

ICSharpCode.NRefactory.CSharp/Resolver/LambdaResolveResult.cs

@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Produces a conversion with <see cref="Conversion.IsAnonymousFunctionConversion"/>=<c>true</c> if the lambda is valid;
 		/// otherwise returns <see cref="Conversion.None"/>.
 		/// </returns>
-		public abstract Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions);
+		public abstract Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions);
 		
 		/// <summary>
 		/// Gets the resolve result for the lambda body.

ICSharpCode.NRefactory.CSharp/Resolver/MethodGroupResolveResult.cs

@@ -160,7 +160,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				foreach (var method in methodGroup) {
 					IType[] inferredTypes;
 					if (CSharpResolver.IsEligibleExtensionMethod(
-						method.Compilation, Conversions.Get(method.Compilation),
+						method.Compilation, CSharpConversions.Get(method.Compilation),
 						this.TargetType, method, true, out inferredTypes))
 					{
 						if (substituteInferredTypes && inferredTypes != null) {
@@ -181,7 +181,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return string.Format("[{0} with {1} method(s)]", GetType().Name, this.Methods.Count());
 		}
 		
-		public OverloadResolution PerformOverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, bool allowExtensionMethods = true, bool allowExpandingParams = true, Conversions conversions = null)
+		public OverloadResolution PerformOverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, bool allowExtensionMethods = true, bool allowExpandingParams = true, CSharpConversions conversions = null)
 		{
 			Log.WriteLine("Performing overload resolution for " + this);
 			Log.WriteCollection("  Arguments: ", arguments);

ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs

@@ -125,14 +125,14 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		readonly ICompilation compilation;
 		readonly ResolveResult[] arguments;
 		readonly string[] argumentNames;
-		readonly Conversions conversions;
+		readonly CSharpConversions conversions;
 		//List<Candidate> candidates = new List<Candidate>();
 		Candidate bestCandidate;
 		Candidate bestCandidateAmbiguousWith;
 		IType[] explicitlyGivenTypeArguments;
 		
 		#region Constructor
-		public OverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, IType[] typeArguments = null, Conversions conversions = null)
+		public OverloadResolution(ICompilation compilation, ResolveResult[] arguments, string[] argumentNames = null, IType[] typeArguments = null, CSharpConversions conversions = null)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
@@ -150,7 +150,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (typeArguments != null && typeArguments.Length > 0)
 				this.explicitlyGivenTypeArguments = typeArguments;
 			
-			this.conversions = conversions ?? Conversions.Get(compilation);
+			this.conversions = conversions ?? CSharpConversions.Get(compilation);
 			this.AllowExpandingParams = true;
 		}
 		#endregion
@@ -392,7 +392,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		sealed class ConstraintValidatingSubstitution : TypeParameterSubstitution
 		{
-			readonly Conversions conversions;
+			readonly CSharpConversions conversions;
 			public bool ConstraintsValid = true;
 			
 			public ConstraintValidatingSubstitution(IList<IType> classTypeArguments, IList<IType> methodTypeArguments, OverloadResolution overloadResolution)
@@ -441,10 +441,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				throw new ArgumentNullException("typeParameter.Owner");
 			if (typeArgument == null)
 				throw new ArgumentNullException("typeArgument");
-			return ValidateConstraints(typeParameter, typeArgument, substitution, Conversions.Get(typeParameter.Owner.Compilation));
+			return ValidateConstraints(typeParameter, typeArgument, substitution, CSharpConversions.Get(typeParameter.Owner.Compilation));
 		}
 		
-		internal static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution, Conversions conversions)
+		internal static bool ValidateConstraints(ITypeParameter typeParameter, IType typeArgument, TypeVisitor substitution, CSharpConversions conversions)
 		{
 			switch (typeArgument.Kind) { // void, null, and pointers cannot be used as type arguments
 				case TypeKind.Void:

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -1846,7 +1846,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return true;
 			}
 			
-			public override Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions)
+			public override Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions)
 			{
 				Log.WriteLine("Testing validity of {0} for return-type {1}...", this, returnType);
 				Log.Indent();
@@ -1996,7 +1996,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return parameters; }
 			}
 			
-			public override Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions)
+			public override Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions)
 			{
 				Log.WriteLine("Testing validity of {0} for parameters ({1}) and return-type {2}...",
 				              this, string.Join<IType>(", ", parameterTypes), returnType);
@@ -2179,7 +2179,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				return c;
 			}
 			
-			public Conversion IsValid(IType returnType, Conversions conversions)
+			public Conversion IsValid(IType returnType, CSharpConversions conversions)
 			{
 				bool valid = success && IsValidLambda(isValidAsVoidMethod, isEndpointUnreachable, lambda.IsAsync, returnValues, returnType, conversions);
 				return new AnonymousFunctionConversion(returnType, this, valid);
@@ -2373,7 +2373,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				|| expr is AssignmentExpression;
 		}
 		
-		static bool IsValidLambda(bool isValidAsVoidMethod, bool isEndpointUnreachable, bool isAsync, IList<ResolveResult> returnValues, IType returnType, Conversions conversions)
+		static bool IsValidLambda(bool isValidAsVoidMethod, bool isEndpointUnreachable, bool isAsync, IList<ResolveResult> returnValues, IType returnType, CSharpConversions conversions)
 		{
 			if (returnType.Kind == TypeKind.Void) {
 				// Lambdas that are valid statement lambdas or expression lambdas with a statement-expression
@@ -3143,7 +3143,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return parameters; }
 			}
 			
-			public override Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions)
+			public override Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions)
 			{
 				if (parameterTypes.Length == parameters.Length) {
 					this.inferredParameterTypes = parameterTypes;

ICSharpCode.NRefactory.CSharp/Resolver/TypeInference.cs

@@ -50,7 +50,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	public sealed class TypeInference
 	{
 		readonly ICompilation compilation;
-		readonly Conversions conversions;
+		readonly CSharpConversions conversions;
 		TypeInferenceAlgorithm algorithm = TypeInferenceAlgorithm.CSharp4;
 		
 		// determines the maximum generic nesting level; necessary to avoid infinite recursion in 'Improved' mode.
@@ -63,10 +63,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			this.compilation = compilation;
-			this.conversions = Conversions.Get(compilation);
+			this.conversions = CSharpConversions.Get(compilation);
 		}
 		
-		internal TypeInference(ICompilation compilation, Conversions conversions)
+		internal TypeInference(ICompilation compilation, CSharpConversions conversions)
 		{
 			Debug.Assert(compilation != null);
 			Debug.Assert(conversions != null);

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

@@ -36,13 +36,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	public unsafe class ConversionsTest
 	{
 		ICompilation compilation;
-		Conversions conversions;
+		CSharpConversions conversions;
 		
 		[SetUp]
 		public void SetUp()
 		{
 			compilation = new SimpleCompilation(CecilLoaderTests.Mscorlib);
-			conversions = new Conversions(compilation);
+			conversions = new CSharpConversions(compilation);
 		}
 		
 		Conversion ImplicitConversion(Type from, Type to)

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

@@ -232,7 +232,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return parameters; }
 			}
 			
-			public override Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions)
+			public override Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions)
 			{
 				return conversions.ImplicitConversion(inferredReturnType, returnType);
 			}

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

@@ -174,7 +174,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { return parameters; }
 			}
 			
-			public override Conversion IsValid(IType[] parameterTypes, IType returnType, Conversions conversions)
+			public override Conversion IsValid(IType[] parameterTypes, IType returnType, CSharpConversions conversions)
 			{
 				Assert.AreEqual(expectedParameterTypes, parameterTypes);
 				return conversions.ImplicitConversion(inferredReturnType, returnType);