Esempio n. 1
0
		protected MethodInfo GetOverloadedBinaryOperator(string name, object operation)
		{
			var leftType = MyLeftChild.ResultType;
			var rightType = MyRightChild.ResultType;
			var binder = new BinaryOperatorBinder(leftType, rightType);

			// If both arguments are of the same type, pick either as the owner type
			if (object.ReferenceEquals(leftType, rightType)) {
				return Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType);
			}

			// Get the operator for both types
			MethodInfo leftMethod = null;
			MethodInfo rightMethod = null;
			leftMethod = Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType);
			rightMethod = Utility.GetOverloadedOperator(name, rightType, binder, leftType, rightType);

			// Pick the right one
			if (leftMethod == null & rightMethod == null) {
				// No operator defined for either
				return null;
			} else if (leftMethod == null) {
				return rightMethod;
			} else if (rightMethod == null) {
				return leftMethod;
			} else {
				// Ambiguous call
				base.ThrowAmbiguousCallException(leftType, rightType, operation);
				return null;
			}
		}
Esempio n. 2
0
 /// <summary>
 /// Promote the left and right operand types
 /// </summary>
 /// <param name="binaryOperatorKind">the operator kind</param>
 /// <param name="leftNode">the left operand</param>
 /// <param name="rightNode">the right operand</param>
 /// <param name="typeReference">type reference for the result BinaryOperatorNode.</param>
 public virtual void PromoteBinaryOperandTypes(
     BinaryOperatorKind binaryOperatorKind,
     ref SingleValueNode leftNode,
     ref SingleValueNode rightNode,
     out IEdmTypeReference typeReference)
 {
     typeReference = null;
     BinaryOperatorBinder.PromoteOperandTypes(binaryOperatorKind, ref leftNode, ref rightNode);
 }
Esempio n. 3
0
        public void CollectionRightTokenShouldFail()
        {
            this.binaryOperatorBinder = new BinaryOperatorBinder(this.BindMethodThatReturnsQueryNode, /*resolver*/ null);
            this.leftQueryNode        = new ConstantNode("People");
            this.rightQueryNode       = new EntitySetNode(this.model.FindDeclaredEntitySet("People"));
            var    binaryOperatorToken = new BinaryOperatorToken(BinaryOperatorKind.Equal, new LiteralToken("foo"), new LiteralToken("bar"));
            Action bind = () => this.binaryOperatorBinder.BindBinaryOperator(binaryOperatorToken);

            bind.Throws <ODataException>(Strings.MetadataBinder_BinaryOperatorOperandNotSingleValue("Equal"));
        }
Esempio n. 4
0
        protected MethodInfo GetOverloadedBinaryOperator(string name, object operation)
        {
            Type leftType  = MyLeftChild.ResultType;
            Type rightType = MyRightChild.ResultType;
            BinaryOperatorBinder binder = new BinaryOperatorBinder(leftType, rightType);

            // If both arguments are of the same type, pick either as the owner type
            if (object.ReferenceEquals(leftType, rightType))
            {
                return(Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType));
            }

            // Get the operator for both types
            MethodInfo leftMethod  = default(MethodInfo);
            MethodInfo rightMethod = default(MethodInfo);

            leftMethod  = Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType);
            rightMethod = Utility.GetOverloadedOperator(name, rightType, binder, leftType, rightType);

            // Pick the right one
            if (leftMethod == null & rightMethod == null)
            {
                // No operator defined for either
                return(null);
            }
            else if (leftMethod == null)
            {
                return(rightMethod);
            }
            else if (rightMethod == null)
            {
                return(leftMethod);
            }
            else if (object.ReferenceEquals(leftMethod, rightMethod))
            {
                // same operator for both (most likely defined in a common base class)
                return(leftMethod);
            }
            else
            {
                // Ambiguous call
                base.ThrowAmbiguousCallException(leftType, rightType, operation);
                return(null);
            }
        }
Esempio n. 5
0
        protected MethodInfo?GetOverloadedBinaryOperator(string name, object operation)
        {
            var leftType  = LeftChild.ResultType;
            var rightType = RightChild.ResultType;
            var binder    = new BinaryOperatorBinder(leftType, rightType);

            // If both arguments are of the same type, pick either as the owner type
            if (ReferenceEquals(leftType, rightType))
            {
                return(Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType));
            }

            // Get the operator for both types
            var leftMethod  = Utility.GetOverloadedOperator(name, leftType, binder, leftType, rightType);
            var rightMethod = Utility.GetOverloadedOperator(name, rightType, binder, leftType, rightType);

            // Pick the right one
            if (leftMethod == null & rightMethod == null)
            {
                // No operator defined for either
                return(null);
            }

            if (leftMethod == null)
            {
                return(rightMethod);
            }

            if (rightMethod == null)
            {
                return(leftMethod);
            }

            //Ambiguous call
            throw CreateCompileException(CompileErrors.AmbiguousOverloadedOperator, CompileExceptionReason.AmbiguousMatch,
                                         leftType.Name, rightType.Name, operation);
        }
Esempio n. 6
0
 public void Init()
 {
     this.shouldReturnLeft     = true;
     this.binaryOperatorBinder = new BinaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode, /*resolver*/ null);
 }
Esempio n. 7
0
 public BinaryOperatorBinderTests()
 {
     this.shouldReturnLeft     = true;
     this.binaryOperatorBinder = new BinaryOperatorBinder(this.BindMethodThatReturnsSingleValueQueryNode, ODataUriResolver.GetUriResolver(null));
 }