public override void VisitConditionalExpression(ConditionalExpression conditionalExpression)
            {
                conditionalExpression.Condition.AcceptVisitor(this);
                var resolveResult = resolver.Resolve(conditionalExpression.Condition);

                if (resolveResult.ConstantValue is bool)
                {
                    if ((bool)resolveResult.ConstantValue)
                    {
                        conditionalExpression.TrueExpression.AcceptVisitor(this);
                    }
                    else
                    {
                        conditionalExpression.FalseExpression.AcceptVisitor(this);
                    }
                    return;
                }
                var nextEndNode = new VariableReferenceNode();
                var trueNode    = CreateNode(references, resolver, conditionalExpression.TrueExpression, null,
                                             nextEndNode);
                var falseNode = CreateNode(references, resolver, conditionalExpression.FalseExpression, null,
                                           nextEndNode);

                endNode.AddNextNode(trueNode);
                endNode.AddNextNode(falseNode);
                endNode = nextEndNode;
            }
            VariableReferenceNode AddNode(ControlFlowNode startNode)
            {
                var node   = new VariableReferenceNode();
                var cfNode = startNode;

                while (true)
                {
                    if (variableReferenceGraphBuilder.ctx.CancellationToken.IsCancellationRequested)
                    {
                        return(null);
                    }
                    if (nodeDict.ContainsKey(cfNode))
                    {
                        node.AddNextNode(nodeDict [cfNode]);
                        break;
                    }
                    // create a new node for fork point
                    if (cfNode.Incoming.Count > 1 || cfNode.Outgoing.Count > 1)
                    {
                        nodeDict [cfNode] = node;

                        var forkNode = new VariableReferenceNode();
                        node.AddNextNode(forkNode);
                        node = forkNode;
                    }
                    nodeDict [cfNode] = node;

                    if (IsValidControlFlowNode(cfNode) && refStatements.Contains(cfNode.NextStatement))
                    {
                        node = GetStatementEndNode(node, cfNode.NextStatement);
                    }

                    if (cfNode.Outgoing.Count == 1)
                    {
                        cfNode = cfNode.Outgoing [0].To;
                    }
                    else
                    {
                        foreach (var e in cfNode.Outgoing)
                        {
                            node.AddNextNode(AddNode(e.To));
                        }
                        break;
                    }
                }
                VariableReferenceNode result;

                if (!nodeDict.TryGetValue(startNode, out result))
                {
                    return(new VariableReferenceNode());
                }
                return(result);
            }