C# IfElseStatement.ReplaceWith方法代码示例

        public override void VisitIfElseStatement(IfElseStatement node)
        {
            VisitChildren(node);

            var yes = node.TrueStatement;
            var no = node.FalseStatement;
            var constant = BoolConstant(node.Condition);

            // Special-case constant conditions
            if (constant == true) {
                node.ReplaceWith(yes); // Inline "if (true)"
            } else if (constant == false) {
                node.ReplaceWith(no); // Inline "if (false)"
            }

            // Inline single statements
            else {
                ReplaceBlockWithSingleStatement(no);
                if (no.IsNull) {
                    ReplaceBlockWithSingleStatement(yes);
                }

                // Be careful to avoid the dangling-else issue
                else {
                    var block = yes as BlockStatement;
                    if (block != null) {
                        var statements = block.Statements;
                        if (statements.Count == 1) {
                            var first = statements.FirstOrNullObject();
                            var ifElse = first as IfElseStatement;
                            if (ifElse == null || !ifElse.FalseStatement.IsNull) {
                                yes.ReplaceWith(first);
                            }
                        }
                    }
                }
            }
        }

        public override void VisitIfElseStatement(IfElseStatement ifElseStatement)
        {
            base.VisitIfElseStatement(ifElseStatement);

            if (ifElseStatement.Condition is PrimitiveExpression &&
                (ifElseStatement.Condition as PrimitiveExpression).Value is bool)
            {
                var value = (bool)(ifElseStatement.Condition as PrimitiveExpression).Value;
                if (value)
                    ifElseStatement.ReplaceWith(ifElseStatement.TrueStatement);
                else
                    ifElseStatement.ReplaceWith(ifElseStatement.FalseStatement);
            }
        }

        public override void VisitIfElseStatement(IfElseStatement e)
        {
            base.VisitIfElseStatement(e);

            #region 删除永远不会成立的条件表达式
            //if (!true)
            //{
            //    ……
            //}
            //====>删除

            var ue = e.Condition as UnaryOperatorExpression;
            if (ue != null && ue.Expression is PrimitiveExpression)
            {
                var pe = ue.Expression as PrimitiveExpression;
                if (object.Equals(pe.Value, ue.Operator == UnaryOperatorType.Not))
                {
                    // 条件始终不成立
                    if (e.FalseStatement.IsNull)
                    {
                        // 删除：if (false) {……}、if (!true) {……}
                        e.Remove();
                    }
                    else
                    {
                        // 用 else 语句体代替条件语句
                        e.ReplaceWith(e.FalseStatement.Detach());
                    }
                }
                else
                {
                    // 条件始终成立
                    if (e.TrueStatement.IsNull)
                    {
                        // 删除：if (true) { }、if (!false) { }
                        e.Remove();
                    }
                    else
                    {
                        e.ReplaceWith(e.TrueStatement.Detach());
                    }
                }
                return;
            }
            #endregion
            #region 精简方法代理的使用
            //if (ModifierGroup.CS$<>9__CachedAnonymousMethodDelegatee == null)
            //{
            //    ModifierGroup.CS$<>9__CachedAnonymousMethodDelegatee = new Action<IChartModifier, ModifierEventArgsBase>(ModifierGroup.TB);
            //}
            //this.TB(ModifierGroup.CS$<>9__CachedAnonymousMethodDelegatee, e);
            //====>
            //this.TB(ModifierGroup.TB, e);

            var be = e.Condition as BinaryOperatorExpression;
            if (be != null &&
                be.Operator == BinaryOperatorType.Equality &&
                be.Left is MemberReferenceExpression &&
                be.Right is NullReferenceExpression &&
                e.FalseStatement.IsNull &&
                e.TrueStatement.Children.Count() == 1 &&
                e.TrueStatement.FirstChild is ExpressionStatement)
            {
                var fr = be.Left.Annotation<FieldDefinition>();
                if (fr == null) return;
                if (!fr.IsCompilerGenerated()) return;

                var es = e.TrueStatement.FirstChild as ExpressionStatement;
                var assignment = es.Expression as AssignmentExpression;
                if (assignment == null) return;
                if (assignment.Left.Annotation<FieldDefinition>() != fr) return;

                Expression methodEpx = null;
                var creation = assignment.Right as ObjectCreateExpression;
                if (creation != null)
                {
                    var oc = assignment.Right as ObjectCreateExpression;
                    if (oc.Arguments.Count != 1) return;

                    var tr = oc.Type.Annotation<TypeReference>();
                    if (tr == null) return;

                    var td = tr.Resolve();
                    if (td == null || !td.IsDelegate()) return;

                    methodEpx = oc.Arguments.First();
                }
                else if (assignment.Right is AnonymousMethodExpression)
                {
                    methodEpx = assignment.Right as AnonymousMethodExpression;
                }
                else
                {
                    methodEpx = assignment.Right as LambdaExpression;
                }
                if (methodEpx != null)
                {
                    var parent = e.Parent;
                    e.Remove();
                    foreach (var x in parent.Descendants.Where(x => x.Annotation<FieldDefinition>() == fr))
//.........这里部分代码省略.........