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

        protected virtual void BindBinaryExpression(BinaryExpression node)
        {
            if (IsEnumOperation(node))
            {
                BindEnumOperation(node);
                return;
            }

            switch (node.Operator)
            {
                case BinaryOperatorType.Assign:
                    {
                        BindAssignment(node);
                        break;
                    }

                case BinaryOperatorType.Addition:
                    {
                        if (GetExpressionType(node.Left).IsArray && GetExpressionType(node.Right).IsArray)
                            BindArrayAddition(node);
                        else
                            BindArithmeticOperator(node);
                        break;
                    }

                case BinaryOperatorType.Subtraction:
                case BinaryOperatorType.Multiply:
                case BinaryOperatorType.Division:
                case BinaryOperatorType.Modulus:
                case BinaryOperatorType.Exponentiation:
                    {
                        BindArithmeticOperator(node);
                        break;
                    }

                case BinaryOperatorType.TypeTest:
                    {
                        BindTypeTest(node);
                        break;
                    }

                case BinaryOperatorType.ReferenceEquality:
                    {
                        BindReferenceEquality(node);
                        break;
                    }

                case BinaryOperatorType.ReferenceInequality:
                    {
                        BindReferenceEquality(node, true);
                        break;
                    }

                case BinaryOperatorType.Or:
                case BinaryOperatorType.And:
                    {
                        BindExpressionType(node, GetMostGenericType(node));
                        break;
                    }

                case BinaryOperatorType.BitwiseAnd:
                case BinaryOperatorType.BitwiseOr:
                case BinaryOperatorType.ExclusiveOr:
                case BinaryOperatorType.ShiftLeft:
                case BinaryOperatorType.ShiftRight:
                    {
                        BindBitwiseOperator(node);
                        break;
                    }

                case BinaryOperatorType.InPlaceSubtraction:
                case BinaryOperatorType.InPlaceAddition:
                    {
                        BindInPlaceAddSubtract(node);
                        break;
                    }

                case BinaryOperatorType.InPlaceShiftLeft:
                case BinaryOperatorType.InPlaceShiftRight:
                case BinaryOperatorType.InPlaceDivision:
                case BinaryOperatorType.InPlaceMultiply:
                case BinaryOperatorType.InPlaceModulus:
                case BinaryOperatorType.InPlaceBitwiseOr:
                case BinaryOperatorType.InPlaceBitwiseAnd:
                case BinaryOperatorType.InPlaceExclusiveOr:
                {
                    BindInPlaceArithmeticOperator(node);
                    break;
                }

                case BinaryOperatorType.GreaterThan:
                case BinaryOperatorType.GreaterThanOrEqual:
                case BinaryOperatorType.LessThan:
                case BinaryOperatorType.LessThanOrEqual:
                case BinaryOperatorType.Inequality:
                case BinaryOperatorType.Equality:
                    {
                        BindCmpOperator(node);
                        break;
                    }

                default:
                    {
                        if (!ResolveOperator(node))
                        {
                            InvalidOperatorForTypes(node);
                        }
                        break;
                    }
            }
        }