/// <summary>
        /// Constructs a custom conversion rule.
        /// </summary>
        /// <param name="conversion">The conversion operation.</param>
        public CustomConversionRule(Conversion conversion)
        {
            if (conversion == null)
                throw new ArgumentNullException("conversion");

            this.conversion = conversion;
        }

 private BinaryOperatorAnalysisResult(OperatorAnalysisResultKind kind, BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion)
 {
     this.Kind = kind;
     this.Signature = signature;
     this.LeftConversion = leftConversion;
     this.RightConversion = rightConversion;
 }

        private ForEachEnumeratorInfo(
            TypeSymbol collectionType,
            TypeSymbol elementType,
            MethodSymbol getEnumeratorMethod,
            MethodSymbol currentPropertyGetter,
            MethodSymbol moveNextMethod,
            bool needsDisposeMethod,
            Conversion collectionConversion,
            Conversion currentConversion,
            Conversion enumeratorConversion,
            BinderFlags location)
        {
            Debug.Assert((object)collectionType != null, "Field 'collectionType' cannot be null");
            Debug.Assert((object)elementType != null, "Field 'elementType' cannot be null");
            Debug.Assert((object)getEnumeratorMethod != null, "Field 'getEnumeratorMethod' cannot be null");
            Debug.Assert((object)currentPropertyGetter != null, "Field 'currentPropertyGetter' cannot be null");
            Debug.Assert((object)moveNextMethod != null, "Field 'moveNextMethod' cannot be null");

            this.CollectionType = collectionType;
            this.ElementType = elementType;
            this.GetEnumeratorMethod = getEnumeratorMethod;
            this.CurrentPropertyGetter = currentPropertyGetter;
            this.MoveNextMethod = moveNextMethod;
            this.NeedsDisposeMethod = needsDisposeMethod;
            this.CollectionConversion = collectionConversion;
            this.CurrentConversion = currentConversion;
            this.EnumeratorConversion = enumeratorConversion;
            this.Location = location;
        }

 public ConversationWrapper(Conversion conv, Operand op, Type @from, Type to)
 {
     _conv = conv;
     _op = op;
     _to = to;
     _from = @from;
 }

			public void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType)
			{
				if (!nodesWithConversions.Add(expression))
					throw new InvalidOperationException("Duplicate ProcessConversion() call");
				if (!conversion.IsValid && !allowErrors) {
					Console.WriteLine("Compiler error at " + fileName + ":" + expression.StartLocation + ": Cannot convert from " + result + " to " + targetType);
				}
			}

 static void Main()
 {
     Conversion conversions = new Conversion();
     double fahr = 62;
     double celc = 30;
     Console.WriteLine("140 fahrenheit is " + conversions.FarToCel(fahr));
     Console.WriteLine("30 celcius is " + conversions.CelToFar(celc));
 }

		public ConversionResolveResult(IType targetType, ResolveResult input, Conversion conversion)
			: base(targetType)
		{
			if (input == null)
				throw new ArgumentNullException("input");
			this.Input = input;
			this.Conversion = conversion;
		}

 protected BoundExpression CreateConversion(
     BoundExpression source,
     Conversion conversion,
     TypeSymbol destination,
     DiagnosticBag diagnostics)
 {
     return CreateConversion(source.Syntax, source, conversion, isCast: false, destination: destination, diagnostics: diagnostics);
 }

		void TestCast(Type targetType, ResolveResult input, Conversion expectedConversion)
		{
			IType type = targetType.ToTypeReference().Resolve(context);
			ResolveResult rr = resolver.ResolveCast(type, input);
			AssertType(targetType, rr);
			Assert.AreEqual(typeof(ConversionResolveResult), rr.GetType());
			var crr = (ConversionResolveResult)rr;
			Assert.AreEqual(expectedConversion, crr.Conversion, "ConversionResolveResult.Conversion");
			Assert.AreSame(input, crr.Input, "ConversionResolveResult.Input");
		}

        public void SelectsConversion()
        {
            var spec = new IntegerGreaterThanZero();
            var converter = (Expression<Func<double, int>>)(d => Math.Sign(d));
            var convertedSpec = new Conversion<double, int>(spec, converter);

            Assert.That(convertedSpec.IsSatisfiedBy(1), Is.True);
            Assert.That(convertedSpec.IsSatisfiedBy(0), Is.False);
            Assert.That(convertedSpec.IsSatisfiedBy(-1), Is.False);
        }

		void TestOperator(ResolveResult condition, ResolveResult trueExpr, ResolveResult falseExpr,
		                  Conversion conditionConv, Conversion trueConv, Conversion falseConv,
		                  Type expectedResultType)
		{
			var corr = (ConditionalOperatorResolveResult)resolver.ResolveConditional(condition, trueExpr, falseExpr);
			AssertType(expectedResultType, corr);
			AssertConversion(corr.Condition, condition, conditionConv, "Condition Conversion");
			AssertConversion(corr.True, trueExpr, trueConv, "True Conversion");
			AssertConversion(corr.False, falseExpr, falseConv, "False Conversion");
		}

		void TestCast(Type targetType, ResolveResult input, Conversion expectedConversion)
		{
			IType type = compilation.FindType(targetType);
			ResolveResult rr = resolver.ResolveCast(type, input);
			AssertType(targetType, rr);
			Assert.AreEqual(typeof(ConversionResolveResult), rr.GetType());
			var crr = (ConversionResolveResult)rr;
			Assert.AreEqual(expectedConversion, crr.Conversion, "ConversionResolveResult.Conversion");
			Assert.AreSame(input, crr.Input, "ConversionResolveResult.Input");
		}

        public static Conversion Is(this Tuple<Measurement, Measurement> conversion, decimal absolute)
        {
            decimal scalar = absolute / conversion.Item1.Value;

            var result = new Conversion(conversion.Item1.Unit, conversion.Item2.Unit);

            result.AddStep(new ScalingConversion(scalar));

            return result;
        }

        private BoundExpression MakeAsOperator(
            BoundAsOperator oldNode,
            CSharpSyntaxNode syntax,
            BoundExpression rewrittenOperand,
            BoundTypeExpression rewrittenTargetType,
            Conversion conversion,
            TypeSymbol rewrittenType)
        {
            // TODO: Handle dynamic operand type and target type
            Debug.Assert(rewrittenTargetType.Type.Equals(rewrittenType));

            // target type cannot be a non-nullable value type
            Debug.Assert(!rewrittenType.IsValueType || rewrittenType.IsNullableType());

            if (!_inExpressionLambda)
            {
                ConstantValue constantValue = Binder.GetAsOperatorConstantResult(rewrittenOperand.Type, rewrittenType, conversion.Kind, rewrittenOperand.ConstantValue);

                if (constantValue != null)
                {
                    Debug.Assert(constantValue.IsNull);
                    BoundExpression result = rewrittenType.IsNullableType() ? new BoundDefaultOperator(syntax, rewrittenType) : MakeLiteral(syntax, constantValue, rewrittenType);

                    if (rewrittenOperand.ConstantValue != null)
                    {
                        // No need to preserve any side-effects from the operand. 
                        // We also can keep the "constant" notion of the result, which
                        // enables some optimizations down the road.
                        return result;
                    }

                    return new BoundSequence(
                        syntax: syntax,
                        locals: ImmutableArray<LocalSymbol>.Empty,
                        sideEffects: ImmutableArray.Create<BoundExpression>(rewrittenOperand),
                        value: result,
                        type: rewrittenType);
                }

                if (conversion.IsImplicit)
                {
                    // Operand with bound implicit conversion to target type.
                    // We don't need a runtime check, generate a conversion for the operand instead.
                    return MakeConversionNode(syntax, rewrittenOperand, conversion, rewrittenType, @checked: false);
                }
            }

            return oldNode.Update(rewrittenOperand, rewrittenTargetType, conversion, rewrittenType);
        }

 private UserDefinedConversionAnalysis(
     UserDefinedConversionAnalysisKind kind,
     MethodSymbol op,
     Conversion sourceConversion,
     Conversion targetConversion,
     TypeSymbol fromType,
     TypeSymbol toType)
 {
     this.Kind = kind;
     this.Operator = op;
     this.SourceConversion = sourceConversion;
     this.TargetConversion = targetConversion;
     this.FromType = fromType;
     this.ToType = toType;
 }

 public static UserDefinedConversionAnalysis Lifted(
     MethodSymbol op,
     Conversion sourceConversion,
     Conversion targetConversion,
     TypeSymbol fromType,
     TypeSymbol toType)
 {
     return new UserDefinedConversionAnalysis(
         UserDefinedConversionAnalysisKind.ApplicableInLiftedForm,
         op,
         sourceConversion,
         targetConversion,
         fromType,
         toType);
 }

        public IEnumerable<Conversion> Conversions()
        {
            XPathNavigator nav = document.CreateNavigator();
            foreach (XPathNavigator n in nav.Select("ucumTests/conversion/case"))
            {
                Conversion conversion = new Conversion();
                conversion.Id = n.SelectSingleNode("@id").Value;
                conversion.Value = n.SelectSingleNode("@value").Value;
                conversion.SourceUnit = n.SelectSingleNode("@srcUnit").Value;
                conversion.DestUnit = n.SelectSingleNode("@dstUnit").Value; 
                conversion.Outcome = n.SelectSingleNode("@outcome").Value;
                //validation.Reason = = n.SelectSingleNode("unit").Value ;
                yield return conversion;

            }
        }

 private float GetAngle(Vector3 vec, Conversion axis)
 {
     switch (axis)
     {
         case Conversion.X:
             return vec.x;
         case Conversion.Y:
             return vec.y;
         case Conversion.Z:
             return vec.z;
         case Conversion.nX:
             return -vec.x;
         case Conversion.nY:
             return -vec.y;
         case Conversion.nZ:
             return -vec.z;
         default:
             return 0;
     }
 }

        public void ConvertsCriteria()
        {
            var spec = new IntegerPredicate(i => i == 0);
            var converter = (Expression<Func<double, int>>)(d => Math.Sign(d));
            var criteria = spec.Criteria;
            var convertedSpec = new Conversion<double, int>(spec, converter);
            var convertedCriteria = convertedSpec.Criteria;

            Assert.That(convertedCriteria.Body, Is.AssignableTo<BinaryExpression>());

            var binary = (BinaryExpression)convertedCriteria.Body;

            Assert.That(binary.NodeType, Is.EqualTo(ExpressionType.Equal));
            Assert.That(binary.Left, Is.EqualTo(converter.Body));
            Assert.That(binary.Right, Is.EqualTo(((BinaryExpression)criteria.Body).Right));
            Assert.That(binary.Method, Is.Null);
            Assert.That(binary.IsLifted, Is.False);
            Assert.That(binary.IsLiftedToNull, Is.False);
            Assert.That(binary.Conversion, Is.Null);

            ExpressionWriter.Write(convertedCriteria);
        }

        private BoundExpression MakeAsOperator(
            BoundAsOperator oldNode,
            CSharpSyntaxNode syntax,
            BoundExpression rewrittenOperand,
            BoundTypeExpression rewrittenTargetType,
            Conversion conversion,
            TypeSymbol rewrittenType)
        {
            // TODO: Handle dynamic operand type and target type
            Debug.Assert(rewrittenTargetType.Type.Equals(rewrittenType));

            // target type cannot be a non-nullable value type
            Debug.Assert(!rewrittenType.IsValueType || rewrittenType.IsNullableType());

            if (!inExpressionLambda)
            {
                ConstantValue constantValue = Binder.GetAsOperatorConstantResult(rewrittenOperand.Type, rewrittenType, conversion.Kind, rewrittenOperand.ConstantValue);
                Debug.Assert(constantValue == null || constantValue.IsNull);

                if (conversion.IsImplicit)
                {
                    // Operand with bound implicit conversion to target type.
                    // We don't need a runtime check, generate a conversion for the operand instead.
                    return MakeConversion(syntax, rewrittenOperand, conversion, rewrittenType, @checked: false, constantValueOpt: constantValue);
                }
                else if (constantValue != null)
                {
                    return new BoundSequence(
                        syntax: syntax,
                        locals: ImmutableArray<LocalSymbol>.Empty,
                        sideEffects: ImmutableArray.Create<BoundExpression>(rewrittenOperand),
                        value: MakeLiteral(syntax, constantValue, rewrittenType),
                        type: rewrittenType);
                }
            }

            return oldNode.Update(rewrittenOperand, rewrittenTargetType, conversion, rewrittenType);
        }