public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
{
BoundSpillSequenceBuilder builder = null;
BoundExpression operand = VisitExpression(ref builder, node.Operand);
return(UpdateExpression(builder, node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.Type)));
}
public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
{
BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
TypeSymbol type = this.VisitType(node.Type);
if (operand.Kind != BoundKind.SpillSequence)
{
return node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, type);
}
var spill = (BoundSpillSequence)operand;
return RewriteSpillSequence(spill,
node.Update(
node.OperatorKind,
spill.Value,
node.ConstantValueOpt,
node.MethodOpt,
node.ResultKind,
type));
}
public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
{
BoundExpression operand = (BoundExpression)this.Visit(node.Operand);
TypeSymbol type = this.VisitType(node.Type);
if (operand.Kind != BoundKind.SpillSequence)
{
return(node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, type));
}
var spill = (BoundSpillSequence)operand;
return(RewriteSpillSequence(spill,
node.Update(
node.OperatorKind,
spill.Value,
node.ConstantValueOpt,
node.MethodOpt,
node.ResultKind,
type)));
}
private BoundExpression MakeUnaryOperator(
BoundUnaryOperator oldNode,
UnaryOperatorKind kind,
SyntaxNode syntax,
MethodSymbol method,
BoundExpression loweredOperand,
TypeSymbol type)
{
if (kind.IsDynamic())
{
Debug.Assert(kind == UnaryOperatorKind.DynamicTrue && type.SpecialType == SpecialType.System_Boolean || type.IsDynamic());
Debug.Assert((object)method == null);
// Logical operators on boxed Boolean constants:
var constant = UnboxConstant(loweredOperand);
if (constant == ConstantValue.True || constant == ConstantValue.False)
{
if (kind == UnaryOperatorKind.DynamicTrue)
{
return(_factory.Literal(constant.BooleanValue));
}
else if (kind == UnaryOperatorKind.DynamicLogicalNegation)
{
return(MakeConversionNode(_factory.Literal(!constant.BooleanValue), type, @checked: false));
}
}
return(_dynamicFactory.MakeDynamicUnaryOperator(kind, loweredOperand, type).ToExpression());
}
else if (kind.IsLifted())
{
if (!_inExpressionLambda)
{
return(LowerLiftedUnaryOperator(kind, syntax, method, loweredOperand, type));
}
}
else if (kind.IsUserDefined())
{
Debug.Assert((object)method != null);
Debug.Assert(type == method.ReturnType);
if (!_inExpressionLambda || kind == UnaryOperatorKind.UserDefinedTrue || kind == UnaryOperatorKind.UserDefinedFalse)
{
return(BoundCall.Synthesized(syntax, null, method, loweredOperand));
}
}
else if (kind.Operator() == UnaryOperatorKind.UnaryPlus)
{
// We do not call the operator even for decimal; we simply optimize it away entirely.
return(loweredOperand);
}
if (kind == UnaryOperatorKind.EnumBitwiseComplement)
{
var underlyingType = loweredOperand.Type.GetEnumUnderlyingType();
var upconvertSpecialType = Binder.GetEnumPromotedType(underlyingType.SpecialType);
var upconvertType = upconvertSpecialType == underlyingType.SpecialType ?
underlyingType :
_compilation.GetSpecialType(upconvertSpecialType);
var newOperand = MakeConversionNode(loweredOperand, upconvertType, false);
UnaryOperatorKind newKind = kind.Operator().WithType(upconvertSpecialType);
var newNode = (oldNode != null) ?
oldNode.Update(
newKind,
newOperand,
oldNode.ConstantValueOpt,
method,
newOperand.ResultKind,
upconvertType) :
new BoundUnaryOperator(
syntax,
newKind,
newOperand,
null,
method,
LookupResultKind.Viable,
upconvertType);
return(MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false));
}
if (kind == UnaryOperatorKind.DecimalUnaryMinus)
{
method = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_Decimal__op_UnaryNegation);
if (!_inExpressionLambda)
{
return(BoundCall.Synthesized(syntax, null, method, loweredOperand));
}
}
return((oldNode != null) ?
oldNode.Update(kind, loweredOperand, oldNode.ConstantValueOpt, method, oldNode.ResultKind, type) :
new BoundUnaryOperator(syntax, kind, loweredOperand, null, method, LookupResultKind.Viable, type));
}
public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
{
BoundSpillSequence2 ss = null;
BoundExpression operand = VisitExpression(ref ss, node.Operand);
return UpdateExpression(ss, node.Update(node.OperatorKind, operand, node.ConstantValueOpt, node.MethodOpt, node.ResultKind, node.Type));
}
private BoundExpression MakeUnaryOperator(
BoundUnaryOperator oldNode,
UnaryOperatorKind kind,
CSharpSyntaxNode syntax,
MethodSymbol method,
BoundExpression loweredOperand,
TypeSymbol type)
{
if (kind.IsDynamic())
{
Debug.Assert(kind == UnaryOperatorKind.DynamicTrue && type.SpecialType == SpecialType.System_Boolean || type.IsDynamic());
Debug.Assert((object)method == null);
// Logical operators on boxed Boolean constants:
var constant = UnboxConstant(loweredOperand);
if (constant == ConstantValue.True || constant == ConstantValue.False)
{
if (kind == UnaryOperatorKind.DynamicTrue)
{
return _factory.Literal(constant.BooleanValue);
}
else if (kind == UnaryOperatorKind.DynamicLogicalNegation)
{
return MakeConversionNode(_factory.Literal(!constant.BooleanValue), type, @checked: false);
}
}
return _dynamicFactory.MakeDynamicUnaryOperator(kind, loweredOperand, type).ToExpression();
}
else if (kind.IsLifted())
{
if (!_inExpressionLambda)
{
return LowerLiftedUnaryOperator(kind, syntax, method, loweredOperand, type);
}
}
else if (kind.IsUserDefined())
{
Debug.Assert((object)method != null);
Debug.Assert(type == method.ReturnType);
if (!_inExpressionLambda || kind == UnaryOperatorKind.UserDefinedTrue || kind == UnaryOperatorKind.UserDefinedFalse)
{
return BoundCall.Synthesized(syntax, null, method, loweredOperand);
}
}
else if (kind.Operator() == UnaryOperatorKind.UnaryPlus)
{
// We do not call the operator even for decimal; we simply optimize it away entirely.
return loweredOperand;
}
if (kind == UnaryOperatorKind.EnumBitwiseComplement)
{
var underlyingType = loweredOperand.Type.GetEnumUnderlyingType();
var upconvertSpecialType = Binder.GetEnumPromotedType(underlyingType.SpecialType);
var upconvertType = upconvertSpecialType == underlyingType.SpecialType ?
underlyingType :
_compilation.GetSpecialType(upconvertSpecialType);
var newOperand = MakeConversionNode(loweredOperand, upconvertType, false);
UnaryOperatorKind newKind = kind.Operator().WithType(upconvertSpecialType);
var newNode = (oldNode != null) ?
oldNode.Update(
newKind,
newOperand,
oldNode.ConstantValueOpt,
method,
newOperand.ResultKind,
upconvertType) :
new BoundUnaryOperator(
syntax,
newKind,
newOperand,
null,
method,
LookupResultKind.Viable,
upconvertType);
return MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false);
}
if (kind == UnaryOperatorKind.DecimalUnaryMinus)
{
method = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_Decimal__op_UnaryNegation);
if (!_inExpressionLambda)
{
return BoundCall.Synthesized(syntax, null, method, loweredOperand);
}
}
return (oldNode != null) ?
oldNode.Update(kind, loweredOperand, oldNode.ConstantValueOpt, method, oldNode.ResultKind, type) :
new BoundUnaryOperator(syntax, kind, loweredOperand, null, method, LookupResultKind.Viable, type);
}
private BoundExpression MakeUnaryOperator(
BoundUnaryOperator oldNode,
UnaryOperatorKind kind,
CSharpSyntaxNode syntax,
MethodSymbol method,
BoundExpression loweredOperand,
TypeSymbol type)
{
if (kind.IsDynamic())
{
Debug.Assert(kind == UnaryOperatorKind.DynamicTrue && type.SpecialType == SpecialType.System_Boolean || type.IsDynamic());
Debug.Assert((object)method == null);
// Logical operators on boxed Boolean constants:
var constant = UnboxConstant(loweredOperand);
if (constant == ConstantValue.True || constant == ConstantValue.False)
{
if (kind == UnaryOperatorKind.DynamicTrue)
{
return(_factory.Literal(constant.BooleanValue));
}
else if (kind == UnaryOperatorKind.DynamicLogicalNegation)
{
return(MakeConversionNode(_factory.Literal(!constant.BooleanValue), type, @checked: false));
}
}
return(_dynamicFactory.MakeDynamicUnaryOperator(kind, loweredOperand, type).ToExpression());
}
else if (kind.IsLifted())
{
if (!_inExpressionLambda)
{
return(LowerLiftedUnaryOperator(kind, syntax, method, loweredOperand, type));
}
}
else if (kind.IsUserDefined())
{
Debug.Assert((object)method != null);
Debug.Assert(type == method.ReturnType);
if (!_inExpressionLambda || kind == UnaryOperatorKind.UserDefinedTrue || kind == UnaryOperatorKind.UserDefinedFalse)
{
// @t-mawind
// As usual, concept accesses need to be rewritten down to their
// default() form.
// Is this correct? It's mostly a copy over from the binary case,
// but the unary case is different enough to make me nervous.
if (method is SynthesizedWitnessMethodSymbol)
{
return(BoundCall.Synthesized(syntax, SynthesizeWitnessInvocationReceiver(syntax, ((SynthesizedWitnessMethodSymbol)method).Parent), method, loweredOperand));
}
return(BoundCall.Synthesized(syntax, null, method, loweredOperand));
}
}
else if (kind.Operator() == UnaryOperatorKind.UnaryPlus)
{
// We do not call the operator even for decimal; we simply optimize it away entirely.
return(loweredOperand);
}
if (kind == UnaryOperatorKind.EnumBitwiseComplement)
{
var underlyingType = loweredOperand.Type.GetEnumUnderlyingType();
var upconvertSpecialType = Binder.GetEnumPromotedType(underlyingType.SpecialType);
var upconvertType = upconvertSpecialType == underlyingType.SpecialType ?
underlyingType :
_compilation.GetSpecialType(upconvertSpecialType);
var newOperand = MakeConversionNode(loweredOperand, upconvertType, false);
UnaryOperatorKind newKind = kind.Operator().WithType(upconvertSpecialType);
var newNode = (oldNode != null) ?
oldNode.Update(
newKind,
newOperand,
oldNode.ConstantValueOpt,
method,
newOperand.ResultKind,
upconvertType) :
new BoundUnaryOperator(
syntax,
newKind,
newOperand,
null,
method,
LookupResultKind.Viable,
upconvertType);
return(MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false));
}
if (kind == UnaryOperatorKind.DecimalUnaryMinus)
{
method = (MethodSymbol)_compilation.Assembly.GetSpecialTypeMember(SpecialMember.System_Decimal__op_UnaryNegation);
if (!_inExpressionLambda)
{
return(BoundCall.Synthesized(syntax, null, method, loweredOperand));
}
}
return((oldNode != null) ?
oldNode.Update(kind, loweredOperand, oldNode.ConstantValueOpt, method, oldNode.ResultKind, type) :
new BoundUnaryOperator(syntax, kind, loweredOperand, null, method, LookupResultKind.Viable, type));
}
