Boo.Lang.Compiler.Steps.ProcessMethodBodies.BindCmpOperator C# (CSharp) Метод

        void BindCmpOperator(BinaryExpression node)
        {
            if (BindNullableComparison(node))
            {
                return;
            }

            IType lhs = GetExpressionType(node.Left);
            IType rhs = GetExpressionType(node.Right);

            if (IsPrimitiveComparison(lhs, rhs))
            {
                BindExpressionType(node, TypeSystemServices.BoolType);
                return;
            }

            if (lhs.IsEnum || rhs.IsEnum)
            {
                if (lhs == rhs
                    || TypeSystemServices.IsPrimitiveNumber(rhs)
                    || TypeSystemServices.IsPrimitiveNumber(lhs))
                {
                    BindExpressionType(node, TypeSystemServices.BoolType);
                }
                else
                {
                    if (!ResolveOperator(node))
                    {
                        InvalidOperatorForTypes(node);
                    }
                }
                return;
            }

            if (!ResolveOperator(node))
            {
                switch (node.Operator)
                {
                    case BinaryOperatorType.Equality:
                        {
                            if (OptimizeNullComparisons
                                && (IsNull(node.Left) || IsNull(node.Right)))
                            {
                                node.Operator = BinaryOperatorType.ReferenceEquality;
                                BindReferenceEquality(node);
                                break;
                            }
                            Expression expression = CreateEquals(node);
                            node.ParentNode.Replace(node, expression);
                            break;
                        }

                    case BinaryOperatorType.Inequality:
                        {
                            if (OptimizeNullComparisons
                                && (IsNull(node.Left) || IsNull(node.Right)))
                            {
                                node.Operator = BinaryOperatorType.ReferenceInequality;
                                BindReferenceEquality(node, true);
                                break;
                            }
                            Expression expression = CreateEquals(node);
                            Node parent = node.ParentNode;
                            parent.Replace(node, CodeBuilder.CreateNotExpression(expression));
                            break;
                        }

                    default:
                        {
                            InvalidOperatorForTypes(node);
                            break;
                        }
                }
            }
        }