public BoundUnaryExpression Update(UnaryOperatorKind operatorKind, OverloadResolutionResult <UnaryOperatorSignature> result, BoundExpression expression)
{
if (operatorKind == OperatorKind && result == Result && expression == Expression)
{
return(this);
}
return(new BoundUnaryExpression(operatorKind, result, expression));
}
private static BoundExpression BindArgument <T>(BoundExpression expression, OverloadResolutionResult <T> result, int argumentIndex) where T : Signature
{
var selected = result.Selected;
if (selected == null)
{
return(expression);
}
var targetType = selected.Signature.GetParameterType(argumentIndex);
var conversion = selected.ArgumentConversions[argumentIndex];
// TODO: We need check for ambiguous conversions here as well.
return(conversion.IsIdentity
? expression
: new BoundConversionExpression(expression, targetType, conversion));
}
public BoundMethodInvocationExpression Update(BoundExpression target, IEnumerable <BoundExpression> arguments, OverloadResolutionResult <MethodSymbolSignature> result)
{
var newArguments = arguments.ToImmutableArray();
if (target == Target && newArguments == Arguments && result == Result)
{
return(this);
}
return(new BoundMethodInvocationExpression(target, newArguments, result));
}
public BoundMethodInvocationExpression(BoundExpression target, IEnumerable <BoundExpression> arguments, OverloadResolutionResult <MethodSymbolSignature> result)
{
Target = target;
Arguments = arguments.ToImmutableArray();
Result = result;
}
public BoundFunctionInvocationExpression Update(IEnumerable <BoundExpression> arguments, OverloadResolutionResult <FunctionSymbolSignature> result)
{
var newArguments = arguments.ToImmutableArray();
if (newArguments == Arguments && result == Result)
{
return(this);
}
return(new BoundFunctionInvocationExpression(newArguments, result));
}
public BoundFunctionInvocationExpression(IEnumerable <BoundExpression> arguments, OverloadResolutionResult <FunctionSymbolSignature> result)
{
Arguments = arguments.ToImmutableArray();
Result = result;
}
public BoundUnaryExpression(UnaryOperatorKind operatorKind, OverloadResolutionResult <UnaryOperatorSignature> result, BoundExpression expression)
{
OperatorKind = operatorKind;
Expression = expression;
Result = result;
}
public BoundBinaryExpression(BoundExpression left, BinaryOperatorKind operatorKind, OverloadResolutionResult <BinaryOperatorSignature> result, BoundExpression right)
{
Left = left;
OperatorKind = operatorKind;
Result = result;
Right = right;
}
public BoundBinaryExpression Update(BoundExpression left, BinaryOperatorKind operatorKind, OverloadResolutionResult <BinaryOperatorSignature> result, BoundExpression right)
{
if (left == Left && operatorKind == OperatorKind && result == Result && right == Right)
{
return(this);
}
return(new BoundBinaryExpression(left, operatorKind, result, right));
}
