private ValueDispatchNode GatherValueDispatchNodes(
                BoundDecisionDagNode node,
                HashSet <BoundDecisionDagNode> loweredNodes,
                BoundDagTemp input)
            {
                IValueSetFactory fac = ValueSetFactory.ForType(input.Type);

                return(GatherValueDispatchNodes(node, loweredNodes, input, fac));
            }
Пример #2
0
        /// <summary>
        /// Given a decision dag and a constant-valued input, produce a simplified decision dag that has removed all the
        /// tests that are unnecessary due to that constant value. This simplification affects flow analysis (reachability
        /// and definite assignment) and permits us to simplify the generated code.
        /// </summary>
        public BoundDecisionDag SimplifyDecisionDagIfConstantInput(BoundExpression input)
        {
            if (input.ConstantValue == null)
            {
                return(this);
            }
            else
            {
                ConstantValue inputConstant = input.ConstantValue;
                return(Rewrite(makeReplacement));

                // Make a replacement for a given node, using the precomputed replacements for its successors.
                BoundDecisionDagNode makeReplacement(BoundDecisionDagNode dag, Func <BoundDecisionDagNode, BoundDecisionDagNode> replacement)
                {
                    if (dag is BoundTestDecisionDagNode p)
                    {
                        // This is the key to the optimization. The result of a top-level test might be known if the input is constant.
                        switch (knownResult(p.Test))
                        {
                        case true:
                            return(replacement(p.WhenTrue));

                        case false:
                            return(replacement(p.WhenFalse));
                        }
                    }

                    return(TrivialReplacement(dag, replacement));
                }

                // Is the decision's result known because the input is a constant?
                bool?knownResult(BoundDagTest choice)
                {
                    if (!choice.Input.IsOriginalInput)
                    {
                        // This is a test of something other than the main input; result unknown
                        return(null);
                    }

                    switch (choice)
                    {
                    case BoundDagExplicitNullTest d:
                        return(inputConstant.IsNull);

                    case BoundDagNonNullTest d:
                        return(!inputConstant.IsNull);

                    case BoundDagValueTest d:
                        return(d.Value == inputConstant);

                    case BoundDagTypeTest d:
                        return(inputConstant.IsNull ? (bool?)false : null);

                    case BoundDagRelationalTest d:
                        var f = ValueSetFactory.ForType(input.Type);
                        if (f is null)
                        {
                            return(null);
                        }
                        // TODO: When ValueSetFactory has a method for comparing two values, use it.
                        var set = f.Related(d.Relation.Operator(), d.Value);
                        return(set.Any(BinaryOperatorKind.Equal, inputConstant));

                    default:
                        throw ExceptionUtilities.UnexpectedValue(choice);
                    }
                }
            }
        }