/// <summary>
        /// Compute the arithmetic operation "opType" over two literal operands and return the result as a QilLiteral.
        /// Arithmetic operations are always checked; in the case of an overflow or divide by zero exception, return
        /// the unfolded result.
        /// </summary>
        private QilNode FoldArithmetic(QilNodeType opType, QilLiteral left, QilLiteral right) {
            Debug.Assert(left.NodeType == right.NodeType);

            // Catch any overflow or divide by zero exceptions
            try {
                checked {
                    switch (left.NodeType) {
                        case QilNodeType.LiteralInt32: {
                            int intLeft = left;
                            int intRight = right;

                            switch (opType) {
                                case QilNodeType.Add: return f.LiteralInt32(intLeft + intRight);
                                case QilNodeType.Subtract: return f.LiteralInt32(intLeft - intRight);
                                case QilNodeType.Multiply: return f.LiteralInt32(intLeft * intRight);
                                case QilNodeType.Divide: return f.LiteralInt32(intLeft / intRight);
                                case QilNodeType.Modulo: return f.LiteralInt32(intLeft % intRight);
                            }
                            break;
                        }

                        case QilNodeType.LiteralInt64: {
                            long lngLeft = left;
                            long lngRight = right;

                            switch (opType) {
                                case QilNodeType.Add: return f.LiteralInt64(lngLeft + lngRight);
                                case QilNodeType.Subtract: return f.LiteralInt64(lngLeft - lngRight);
                                case QilNodeType.Multiply: return f.LiteralInt64(lngLeft * lngRight);
                                case QilNodeType.Divide: return f.LiteralInt64(lngLeft / lngRight);
                                case QilNodeType.Modulo: return f.LiteralInt64(lngLeft % lngRight);
                            }
                            break;
                        }

                        case QilNodeType.LiteralDecimal: {
                            decimal lngLeft = left;
                            decimal lngRight = right;

                            switch (opType) {
                                case QilNodeType.Add: return f.LiteralDecimal(lngLeft + lngRight);
                                case QilNodeType.Subtract: return f.LiteralDecimal(lngLeft - lngRight);
                                case QilNodeType.Multiply: return f.LiteralDecimal(lngLeft * lngRight);
                                case QilNodeType.Divide: return f.LiteralDecimal(lngLeft / lngRight);
                                case QilNodeType.Modulo: return f.LiteralDecimal(lngLeft % lngRight);
                            }
                            break;
                        }

                        case QilNodeType.LiteralDouble: {
                            double lngLeft = left;
                            double lngRight = right;

                            switch (opType) {
                                case QilNodeType.Add: return f.LiteralDouble(lngLeft + lngRight);
                                case QilNodeType.Subtract: return f.LiteralDouble(lngLeft - lngRight);
                                case QilNodeType.Multiply: return f.LiteralDouble(lngLeft * lngRight);
                                case QilNodeType.Divide: return f.LiteralDouble(lngLeft / lngRight);
                                case QilNodeType.Modulo: return f.LiteralDouble(lngLeft % lngRight);
                            }
                            break;
                        }
                    }
                }
            }
            catch (OverflowException) {
            }
            catch (DivideByZeroException) {
            }

            // An error occurred, so don't fold operationo
            switch (opType) {
                case QilNodeType.Add: return f.Add(left, right);
                case QilNodeType.Subtract: return f.Subtract(left, right);
                case QilNodeType.Multiply: return f.Multiply(left, right);
                case QilNodeType.Divide: return f.Divide(left, right);
                case QilNodeType.Modulo: return f.Modulo(left, right);
            }

            Debug.Assert(false, "Cannot fold this arithmetic operation: " + opType);
            return null;
        }

 protected override QilNode VisitLiteralDecimal(QilLiteral n) { return NoReplace(n); }

 public XmlQueryType CheckLiteralType(QilLiteral node) {
     CheckLiteralValue(node, typeof(XmlQueryType));
     return (XmlQueryType) node;
 }

 /// <summary>
 /// Generate code for QilNodeType.LiteralString.
 /// </summary>
 protected override QilNode VisitLiteralString(QilLiteral ndStr)
 {
     _helper.Emit(OpCodes.Ldstr, (string)ndStr);
     _iterCurr.Storage = StorageDescriptor.Stack(typeof(string), false);
     return ndStr;
 }

 public XmlQueryType CheckLiteralInt32(QilLiteral node) {
     CheckLiteralValue(node, typeof(int));
     return XmlQueryTypeFactory.IntX;
 }

 public XmlQueryType CheckLiteralDouble(QilLiteral node) {
     CheckLiteralValue(node, typeof(double));
     return XmlQueryTypeFactory.DoubleX;
 }

 public QilLiteral LiteralInt64(long value) {
     QilLiteral n = new QilLiteral(QilNodeType.LiteralInt64, value);
     n.XmlType = this.typeCheck.CheckLiteralInt64(n);
     TraceNode(n);
     return n;
 }

 protected virtual QilNode VisitLiteralObject(QilLiteral n) { return VisitChildren(n); }

 /// <summary>
 /// Generate code for QilNodeType.LiteralDecimal.
 /// </summary>
 protected override QilNode VisitLiteralDecimal(QilLiteral ndDec)
 {
     _helper.ConstructLiteralDecimal((decimal)ndDec);
     _iterCurr.Storage = StorageDescriptor.Stack(typeof(decimal), false);
     return ndDec;
 }

 public QilLiteral LiteralString(string value) {
     QilLiteral n = new QilLiteral(QilNodeType.LiteralString, value);
     n.XmlType = this.typeCheck.CheckLiteralString(n);
     TraceNode(n);
     return n;
 }

 /// <summary>
 /// Generate code for QilNodeType.LiteralDouble.
 /// </summary>
 protected override QilNode VisitLiteralDouble(QilLiteral ndDbl)
 {
     _helper.Emit(OpCodes.Ldc_R8, (double)ndDbl);
     _iterCurr.Storage = StorageDescriptor.Stack(typeof(double), false);
     return ndDbl;
 }

 /// <summary>
 /// Generate code for QilNodeType.LiteralInt64.
 /// </summary>
 protected override QilNode VisitLiteralInt64(QilLiteral ndLong)
 {
     _helper.Emit(OpCodes.Ldc_I8, (long)ndLong);
     _iterCurr.Storage = StorageDescriptor.Stack(typeof(long), false);
     return ndLong;
 }

 /// <summary>
 /// Generate code for QilNodeType.LiteralInt32.
 /// </summary>
 protected override QilNode VisitLiteralInt32(QilLiteral ndInt)
 {
     _helper.LoadInteger((int)ndInt);
     _iterCurr.Storage = StorageDescriptor.Stack(typeof(int), false);
     return ndInt;
 }

 protected override QilNode VisitLiteralObject(QilLiteral n) { return NoReplace(n); }

 public QilLiteral LiteralDouble(double value) {
     QilLiteral n = new QilLiteral(QilNodeType.LiteralDouble, value);
     n.XmlType = this.typeCheck.CheckLiteralDouble(n);
     TraceNode(n);
     return n;
 }

 protected virtual QilNode VisitLiteralDecimal(QilLiteral n) { return VisitChildren(n); }

 public QilLiteral LiteralDecimal(decimal value) {
     QilLiteral n = new QilLiteral(QilNodeType.LiteralDecimal, value);
     n.XmlType = this.typeCheck.CheckLiteralDecimal(n);
     TraceNode(n);
     return n;
 }

 public XmlQueryType CheckLiteralString(QilLiteral node) {
     CheckLiteralValue(node, typeof(string));
     return XmlQueryTypeFactory.StringX;
 }

 public QilLiteral LiteralType(XmlQueryType value) {
     QilLiteral n = new QilLiteral(QilNodeType.LiteralType, value);
     n.XmlType = this.typeCheck.CheckLiteralType(n);
     TraceNode(n);
     return n;
 }

 public XmlQueryType CheckLiteralInt64(QilLiteral node) {
     CheckLiteralValue(node, typeof(long));
     return XmlQueryTypeFactory.IntegerX;
 }