public FalseLiteralContext(ExprContext context) { CopyFrom(context); }

        public BoundExpression VisitExpression(BoundExpression node, ExprContext context)
        {
            var prevContext = _context;
            int prevStack = StackDepth();
            _context = context;

            // Do not recurse into constant expressions. Their children do not push any values.
            var result = node.ConstantValue == null ?
                node = (BoundExpression)base.Visit(node) :
                node;

            _context = prevContext;
            _counter += 1;

            switch (context)
            {
                case ExprContext.Sideeffects:
                    SetStackDepth(prevStack);
                    break;

                case ExprContext.AssignmentTarget:
                    break;

                case ExprContext.Value:
                case ExprContext.Address:
                case ExprContext.Box:
                    SetStackDepth(prevStack);
                    PushEvalStack(node, context);
                    break;

                default:
                    throw ExceptionUtilities.UnexpectedValue(context);
            }

            return result;
        }

        private BoundExpression VisitExpression(BoundExpression node, ExprContext context)
        {
            BoundExpression result;
            _recursionDepth++;

            if (_recursionDepth > 1)
            {
                StackGuard.EnsureSufficientExecutionStack(_recursionDepth);

                result = VisitExpressionCore(node, context);
            }
            else
            {
                result = VisitExpressionCoreWithStackGuard(node, context);
            }

            _recursionDepth--;
            return result;
        }

 private void PushEvalStack(BoundExpression result, ExprContext context)
 {
     Debug.Assert(result != null || context == ExprContext.None);
     _evalStack.Add((result, context));
 }

        public BoundExpression VisitExpression(BoundExpression node, ExprContext context)
        {
            var prevContext = _context;
            int prevStack = _evalStack;

            _context = context;
            var result = ReuseOrVisit(node, context);
            _counter += 1;

            switch (context)
            {
                case ExprContext.Sideeffects:
                    _evalStack = prevStack;
                    break;

                case ExprContext.Value:
                case ExprContext.Address:
                case ExprContext.Box:
                    _evalStack = prevStack + 1;
                    break;

                case ExprContext.AssignmentTarget:
                    _evalStack = prevStack;
                    if (LhsUsesStackWhenAssignedTo(node, context))
                    {
                        _evalStack = prevStack + 1;
                    }
                    break;

                default:
                    throw ExceptionUtilities.UnexpectedValue(context);
            }

            _context = prevContext;
            return result;
        }

        // here we have a case of indirect assignment:  *t1 = expr;
        // normally we would need to push t1 and that will cause spilling of t2
        //
        // TODO: an interesting case arises in unused x[i]++  and ++x[i] :
        //       we have trees that look like:
        //
        //  t1 = &(x[0])
        //  t2 = *t1
        //  *t1 = t2 + 1
        //
        //  t1 = &(x[0])
        //  t2 = *t1 + 1
        //  *t1 = t2
        //
        //  in these cases, we could keep t2 on stack (dev10 does).
        //  we are dealing with exactly 2 locals and access them in strict order 
        //  t1, t2, t1, t2  and we are not using t2 after that.
        //  We may consider detecting exactly these cases and pretend that we do not need 
        //  to push either t1 or t2 in this case.
        //
        private bool LhsUsesStackWhenAssignedTo(BoundNode node, ExprContext context)
        {
            Debug.Assert(context == ExprContext.AssignmentTarget);

            switch (node.Kind)
            {
                case BoundKind.Parameter:
                case BoundKind.Local:
                    return false;

                case BoundKind.FieldAccess:
                    return !((BoundFieldAccess)node).FieldSymbol.IsStatic;

                case BoundKind.Sequence:
                    return LhsUsesStackWhenAssignedTo(((BoundSequence)node).Value, context);
            }

            return true;
        }

		public IfStatementContext(ExprContext context) { CopyFrom(context); }

		public SignContext(ExprContext context) { CopyFrom(context); }

		public TrueLiteralContext(ExprContext context) { CopyFrom(context); }

		public IndexContext(ExprContext context) { CopyFrom(context); }

		public InfLiteralContext(ExprContext context) { CopyFrom(context); }

		public FunctionCallContext(ExprContext context) { CopyFrom(context); }

		public ComplexLiteralContext(ExprContext context) { CopyFrom(context); }

	public ExprContext expr() {
		ExprContext _localctx = new ExprContext(Context, State);
		EnterRule(_localctx, 112, RULE_expr);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 748; xor_expr();
			State = 753;
			ErrorHandler.Sync(this);
			_la = TokenStream.La(1);
			while (_la==OR_OP) {
				{
				{
				State = 749; Match(OR_OP);
				State = 750; xor_expr();
				}
				}
				State = 755;
				ErrorHandler.Sync(this);
				_la = TokenStream.La(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

		public UserOpContext(ExprContext context) { CopyFrom(context); }

        /// <summary>
        /// Recursively rewrites the node or simply replaces it with a dup node
        /// if we have just seen exactly same node.
        /// </summary>
        private BoundExpression ReuseOrVisit(BoundExpression node, ExprContext context)
        {
            if (context == ExprContext.AssignmentTarget || context == ExprContext.Sideeffects)
            {
                return BaseVisitExpression(node);
            }

            // it must be most recent expression
            // it can be a ref when we want a value, but cannot be the other way
            // TODO: we could reuse boxed values, but we would need to make the Dup to know it was boxed
            if (_counter == _lastExpressionCnt + 1 &&
                _lastExprContext != ExprContext.Box &&
                (_lastExprContext == context || _lastExprContext != ExprContext.Value) &&
                CanDup(_lastExpression, node))
            {
                _lastExpressionCnt = _counter;

                // when duping something not created in a Value context, we are actually duping a reference.
                // record that so that codegen could know if it is a value or a reference.
                RefKind dupRefKind = _lastExprContext == ExprContext.Value ?
                                                    RefKind.None :
                                                    RefKind.Ref;

                // change the context to the most recently used. 
                // Why? If we obtained a value from a duped reference, we now have a value on the stack.
                _lastExprContext = context;

                return new BoundDup(node.Syntax, dupRefKind, node.Type);
            }
            else
            {
                BoundExpression result = BaseVisitExpression(node);

                _lastExpressionCnt = _counter;
                _lastExprContext = context;
                _lastExpression = result;

                return result;
            }
        }

		public NamespaceContext(ExprContext context) { CopyFrom(context); }

		public NAContext(ExprContext context) { CopyFrom(context); }

        public override BoundNode VisitBinaryOperator(BoundBinaryOperator node)
        {
            BoundExpression child = node.Left;

            if (child.Kind != BoundKind.BinaryOperator || child.ConstantValue != null)
            {
                return VisitBinaryOperatorSimple(node);
            }

            // Do not blow the stack due to a deep recursion on the left.
            var stack = ArrayBuilder<BoundBinaryOperator>.GetInstance();
            stack.Push(node);

            BoundBinaryOperator binary = (BoundBinaryOperator)child;

            while (true)
            {
                stack.Push(binary);
                child = binary.Left;

                if (child.Kind != BoundKind.BinaryOperator || child.ConstantValue != null)
                {
                    break;
                }

                binary = (BoundBinaryOperator)child;
            }

            var prevContext = _context;
            int prevStack = StackDepth();

            var left = (BoundExpression)this.Visit(child);

            while (true)
            {
                binary = stack.Pop();

                var isLogical = (binary.OperatorKind & BinaryOperatorKind.Logical) != 0;

                object cookie = null;
                if (isLogical)
                {
                    cookie = GetStackStateCookie();     // implicit branch here
                    SetStackDepth(prevStack);  // right is evaluated with original stack
                }

                var right = (BoundExpression)this.Visit(binary.Right);

                if (isLogical)
                {
                    EnsureStackState(cookie);   // implicit label here
                }

                var type = this.VisitType(binary.Type);
                left = binary.Update(binary.OperatorKind, left, right, binary.ConstantValueOpt, binary.MethodOpt, binary.ResultKind, type);

                if (stack.Count == 0)
                {
                    break;
                }

                _context = prevContext;
                _counter += 1;
                SetStackDepth(prevStack);
                PushEvalStack(binary, ExprContext.Value);
            }

            Debug.Assert((object)binary == node);
            stack.Free();

            return left;
        }

		public NegationContext(ExprContext context) { CopyFrom(context); }