public override void VisitConditionalExpression(ConditionalExpression conditionalExpression)
		{
            var token = CreateConditionalBlock(conditionalExpression.Condition.GetText());
            _tokenList.Add(token);

            VisitChildren(token.FalseStatements, conditionalExpression.FalseExpression);
            VisitChildren(token.TrueStatements, conditionalExpression.TrueExpression);		
		}        

 protected ConditionalExpression UpdateConditional(ConditionalExpression c, Expression test, Expression ifTrue, Expression ifFalse)
 {
     if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse)
     {
         return Expression.Condition(test, ifTrue, ifFalse);
     }
     return c;
 }

			public override void VisitConditionalExpression (ConditionalExpression conditionalExpression)
			{
				base.VisitConditionalExpression (conditionalExpression);

				if (!conditionalExpression.TrueExpression.Match (conditionalExpression.FalseExpression).Success)
					return;
				var action = new CodeAction (ctx.TranslateString ("Replace '?:' with branch"),
					script => script.Replace (conditionalExpression, conditionalExpression.TrueExpression.Clone ()));
				AddIssue (conditionalExpression, 
					ctx.TranslateString ("'?:' expression has identical true and false branches"), new [] { action });
			}

			public override void VisitConditionalExpression(ConditionalExpression conditionalExpression)
			{
				Match m = pattern.Match(conditionalExpression);
				if (m.Success) {
					var a = m.Get<Expression>("a").Single();
					var other = m.Get<Expression>("other").Single();
					AddIssue(conditionalExpression, ctx.TranslateString("Convert to '??' expression"), script => {
						var expr = new BinaryOperatorExpression (a.Clone (), BinaryOperatorType.NullCoalescing, other.Clone ());
						script.Replace (conditionalExpression, expr);
					});
				}
				base.VisitConditionalExpression (conditionalExpression);
			}

		public Tuple<Expression, Expression> GetExpressions (ConditionalExpression cond)
		{
			var condition = cond.Condition as BinaryOperatorExpression;
			var compareNode = condition.Left is NullReferenceExpression ? condition.Right : condition.Left;

			if (compareNode.IsMatch (cond.TrueExpression)) {
				// a != null ? a : other
				return new Tuple<Expression, Expression> (cond.TrueExpression, cond.FalseExpression);
			}

			// a == null ? other : a
			return new Tuple<Expression, Expression> (cond.FalseExpression, cond.TrueExpression);
		}

		public bool IsCandidate (ConditionalExpression node)
		{
			var condition = node.Condition as BinaryOperatorExpression;
			var compareNode = condition.Left is NullReferenceExpression ? condition.Right : condition.Left;
			
			
			if (compareNode.IsMatch (node.TrueExpression)) {
				// a == null ? a : other
				if (condition.Operator == BinaryOperatorType.Equality) 
					return false;
				// a != null ? a : other
				return compareNode.IsMatch (node.TrueExpression);
			} else {
				// a == null ? other : a
				if (condition.Operator == BinaryOperatorType.Equality)
					return compareNode.IsMatch (node.FalseExpression);
				// a != null ? other : a
				return false;
			}
		}

			public override void VisitConditionalExpression (ConditionalExpression conditionalExpression)
			{
				var resolveResult = ctx.Resolve (conditionalExpression.Condition);
				if (resolveResult.ConstantValue is bool) {
					var condition = (bool)resolveResult.ConstantValue;
					Expression resultExpr, unreachableExpr;
					if (condition) {
						resultExpr = conditionalExpression.TrueExpression;
						unreachableExpr = conditionalExpression.FalseExpression;
					} else {
						resultExpr = conditionalExpression.FalseExpression;
						unreachableExpr = conditionalExpression.TrueExpression;
					}
					unreachableNodes.Add (unreachableExpr);

					AddIssue (unreachableExpr, ctx.TranslateString ("Remove unreachable code"),
						script => script.Replace (conditionalExpression, resultExpr.Clone ()));
				}
				base.VisitConditionalExpression (conditionalExpression);
			}

 // ConditionalExpression
 public override bool Walk(ConditionalExpression node) { return false; }

 // ConditionalExpression
 protected internal virtual bool Walk(ConditionalExpression node) { return true; }

 protected internal virtual void PostWalk(ConditionalExpression node) { }

 public override void Exit(ConditionalExpression node)
 {
     level--;
 }

 public override bool Enter(ConditionalExpression node)
 {
     Print("ConditionalExpression");
     level++;
     return true;
 }

 /**
  * Call back method that must be called as soon as the given <code>
  * ConditionalExpression</code> object has been traversed.
  *
  * @param pConditionalExpression  The <code>ConditionalExpression</code>
  *                                object that has just been traversed.
  */
 public void actionPerformed(
      
     ConditionalExpression pConditionalExpression)
 {
     // Nothing to do.
 }

 public override bool Walk(ConditionalExpression node)
 {
     node.Parent = _currentScope;
     return base.Walk(node);
 }

 public void VisitConditionalExpression(ConditionalExpression condExpr)
 {
     condExpr.Condition.AcceptWalker(this);
     condExpr.TrueExpression.AcceptWalker(this);
     condExpr.FalseExpression.AcceptWalker(this);
 }

		public void VisitConditionalExpression(ConditionalExpression conditionalExpression)
		{
			StartNode(conditionalExpression);
			conditionalExpression.Condition.AcceptVisitor(this);
			
			Space(policy.SpaceBeforeConditionalOperatorCondition);
			WriteToken(ConditionalExpression.QuestionMarkRole);
			Space(policy.SpaceAfterConditionalOperatorCondition);
			
			conditionalExpression.TrueExpression.AcceptVisitor(this);
			
			Space(policy.SpaceBeforeConditionalOperatorSeparator);
			WriteToken(ConditionalExpression.ColonRole);
			Space(policy.SpaceAfterConditionalOperatorSeparator);
			
			conditionalExpression.FalseExpression.AcceptVisitor(this);
			
			EndNode(conditionalExpression);
		}

 public virtual void PostWalk(ConditionalExpression node) { }

 public virtual void VisitConditionalExpression(ConditionalExpression conditionalExpression)
 {
     if (this.ThrowException)
     {
         throw (Exception)this.CreateException(conditionalExpression);
     }
 }

 public ConditionalExpressionProxy(ConditionalExpression node) {
     _node = node;
 }

		// Conditional operator
		public override void VisitConditionalExpression(ConditionalExpression conditionalExpression)
		{
			// Associativity here is a bit tricky:
			// (a ? b : c ? d : e) == (a ? b : (c ? d : e))
			// (a ? b ? c : d : e) == (a ? (b ? c : d) : e)
			// Only ((a ? b : c) ? d : e) strictly needs the additional parentheses
			if (InsertParenthesesForReadability) {
				// Precedence of ?: can be confusing; so always put parentheses in nice-looking mode.
				ParenthesizeIfRequired(conditionalExpression.Condition, Primary);
				ParenthesizeIfRequired(conditionalExpression.TrueExpression, Primary);
				ParenthesizeIfRequired(conditionalExpression.FalseExpression, Primary);
			} else {
				ParenthesizeIfRequired(conditionalExpression.Condition, Conditional + 1);
				ParenthesizeIfRequired(conditionalExpression.TrueExpression, Conditional);
				ParenthesizeIfRequired(conditionalExpression.FalseExpression, Conditional);
			}
			base.VisitConditionalExpression(conditionalExpression);
		}