public BinaryExpressionSyntax(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, ExpressionSyntax right)
: base(kind)
{
RegisterChildNode(out Left, left);
RegisterChildNode(out OperatorToken, operatorToken);
Operator = SyntaxFacts.GetBinaryOperatorKind(kind);
RegisterChildNode(out Right, right);
}
private BoundExpression BindAssignmentExpression(AssignmentExpressionSyntax node)
{
// TODO: Need to apply similar overload resolution as BindBinaryExpression.
var operatorKind = (node.Kind != SyntaxKind.SimpleAssignmentExpression)
? (BinaryOperatorKind?)SyntaxFacts.GetBinaryOperatorKind(node.Kind)
: null;
return(new BoundAssignmentExpression(
Bind(node.Left, BindExpression),
operatorKind,
Bind(node.Right, BindExpression)));
}
public AssignmentExpressionSyntax(SyntaxKind kind, ExpressionSyntax left, SyntaxToken operatorToken, SyntaxToken lessThanToken, ExpressionSyntax right, SyntaxToken greaterThanToken)
: base(kind)
{
RegisterChildNode(out Left, left);
RegisterChildNode(out OperatorToken, operatorToken);
Operator = (kind != SyntaxKind.SimpleAssignmentExpression)
? (BinaryOperatorKind?)SyntaxFacts.GetBinaryOperatorKind(kind)
: null;
RegisterChildNode(out LessThanToken, lessThanToken);
RegisterChildNode(out Right, right);
RegisterChildNode(out GreaterThanToken, greaterThanToken);
}
private BoundBinaryExpression BindBinaryExpression(BinaryExpressionSyntax syntax)
{
var operatorKind = SyntaxFacts.GetBinaryOperatorKind(syntax.Kind);
var boundLeft = Bind(syntax.Left, BindExpression);
var boundRight = Bind(syntax.Right, BindExpression);
if (boundLeft.Type.IsError() || boundRight.Type.IsError())
{
return(new BoundBinaryExpression(operatorKind, boundLeft, boundRight, OverloadResolutionResult <BinaryOperatorSignature> .None));
}
var leftType = boundLeft.Type;
var rightType = boundRight.Type;
var requiresNumericType = operatorKind.RequiresNumericTypes();
var requiresIntegralType = operatorKind.RequiresIntegralTypes();
if (!ValidateTypeForBinaryExpression(leftType, requiresIntegralType, requiresNumericType) ||
!ValidateTypeForBinaryExpression(rightType, requiresIntegralType, requiresNumericType))
{
Diagnostics.ReportCannotApplyBinaryOperator(syntax.OperatorToken, leftType, rightType);
return(new BoundBinaryExpression(operatorKind, boundLeft, boundRight, OverloadResolutionResult <BinaryOperatorSignature> .None));
}
var result = LookupBinaryOperator(operatorKind, boundLeft, boundRight);
if (result.Best == null)
{
if (result.Selected == null)
{
Diagnostics.ReportCannotApplyBinaryOperator(syntax.OperatorToken, boundLeft.Type, boundRight.Type);
}
else
{
Diagnostics.ReportAmbiguousBinaryOperator(syntax.OperatorToken, boundLeft.Type, boundRight.Type);
}
}
// Convert arguments (if necessary)
var convertedLeft = BindArgument(boundLeft, result, 0, syntax.Left.GetTextSpanSafe());
var convertedRight = BindArgument(boundRight, result, 1, syntax.Right.GetTextSpanSafe());
return(new BoundBinaryExpression(operatorKind, convertedLeft, convertedRight, result));
}
