protected virtual BoundExpression RewriteUnaryExpression(BoundUnaryExpression expression) { var operand = RewriteExpression(expression.Operand); if (operand == expression.Operand) { return(expression); } return(new BoundUnaryExpression(expression.Op, operand)); }
protected override BoundExpression RewriteUnaryExpression(BoundUnaryExpression node) { var rewrittenOp = RewriteExpression(node.Operand); var operand = IsSimpleNode(rewrittenOp) ? rewrittenOp : CreateTemporary(rewrittenOp); var @operator = RewriteUnaryOperator(node.Operator); if (node.Operand == operand && node.Operator == @operator) { return(node); } return(new BoundUnaryExpression(node.Syntax, @operator, operand)); }
private object EvaluateUnaryExpression(BoundUnaryExpression u) { var operand = EvaluateExpression(u.Operand); if (u.Op.Type == null) { var conversion = Conversion.Classify(u.Operand.Type, u.Type); if (!conversion.IsImplicit) { throw new Exception($"Can not implicitly cast type {u.Operand.Type} to {u.Type}"); } } return(Conversion.Convert(u.Type, u.Op.Operate(Conversion.Convert(u.Type, operand)))); // Convert twice incase C# changes the type after the operation }
private object EvaluateUnaryExpression(BoundUnaryExpression u) { var operand = this.EvaluateExpression(u.Expression) !; switch (u.Operator.Kind) { case BoundUnaryOperatorKind.Identity: return((int)operand); case BoundUnaryOperatorKind.Negation: return(-(int)operand); case BoundUnaryOperatorKind.LogicalNegation: return(!(bool)operand); default: throw new Exception($"Unexpected unary operator {u.Operator}"); } }
private void EmitUnaryExpression(BoundUnaryExpression expression) { switch (expression.Kind) { case TokenKind.Minus: { this.EmitExpression(expression.Expression); this.instructions.Add(new UnaryMinusInstruction(expression.Syntax.Range)); break; } default: { throw ExceptionUtilities.UnexpectedValue(expression.Kind); } } }
private Expression BuildUnaryExpression(BoundUnaryExpression expression) { var liftedInput = BuildCachedExpression(expression.Expression); var nullableResultType = expression.Type.GetNullableType(); var signature = expression.Result.Best.Signature; return(Expression.Condition( BuildNullCheck(liftedInput), BuildNullValue(nullableResultType), BuildLiftedExpression( BuildUnaryExpression( signature, BuildLoweredExpression(liftedInput) ) ) )); }
private void OutputUnaryExpression(BoundUnaryExpression node, string prefix) { builder.AddFragment(new OutputFragment(prefix, DefaultColour)); builder.AddFragment(new OutputFragment(node.Op.TokenText, DefaultColour)); bool isBinaryExpression = node.Operand is BoundBinaryExpression; if (isBinaryExpression) { builder.AddFragment(new OutputFragment("(", DefaultColour)); } Output(node.Operand, string.Empty); if (isBinaryExpression) { builder.AddFragment(new OutputFragment(")", DefaultColour)); } }
protected override object EvaluateExpression(BoundExpression node) { try { BoundLiteralExpression boundLiteralExpression = (BoundLiteralExpression)node; return(EvaluateLiteralExpression(boundLiteralExpression)); } catch { try { BoundVariableExpression boundVariableExpression = (BoundVariableExpression)node; return(EvaluateVariableExpression(boundVariableExpression)); } catch { try { BoundAssignmentExpression boundAssignmentExpression = (BoundAssignmentExpression)node; return(EvaluateAssignmentExpression(boundAssignmentExpression)); } catch { try { BoundUnaryExpression boundUnaryExpression = (BoundUnaryExpression)node; return(EvaluateUnaryExpression(boundUnaryExpression)); } catch { try { BoundBinaryExpression boundBinaryExpression = (BoundBinaryExpression)node; return(EvaluateBinaryExpression(boundBinaryExpression)); } catch { return(null); } } } } } }
private object Evaluate(BoundUnaryExpression unaryExpression) { var operand = EvaluateExpression(unaryExpression.Operand); switch (unaryExpression.Op.Kind) { case BoundUnaryOperatorKind.Negation: return(-(int)operand); case BoundUnaryOperatorKind.Identity: return((int)operand); case BoundUnaryOperatorKind.LogicalNegation: return(!(bool)operand); case BoundUnaryOperatorKind.BitwiseNegation: return(~(int)operand); default: throw new ArgumentOutOfRangeException(nameof(unaryExpression.Op), unaryExpression.Op, null); } }
private object EvaluateUnaryExpression(BoundUnaryExpression us) { var operand = EvaluateExpression(us.Operand); switch (us.Op.Kind) { case BoundUnaryOperatorKind.Negation: return(-(int)operand); case BoundUnaryOperatorKind.Identity: return((int)operand); case BoundUnaryOperatorKind.LogicalNegation: return(!(bool)operand); case BoundUnaryOperatorKind.OnesComplement: return(~(int)operand); default: throw new Exception($"Unexpected unary operator {us.Kind}"); } }
private object EvaluateUnaryExpression(BoundUnaryExpression u) { var operand = EvaluateExpression(u.Operand); switch (u.Op.Kind) { case BoundUnaryOperatorKind.Identity: return((int)operand); case BoundUnaryOperatorKind.Negation: return(-(int)operand); case BoundUnaryOperatorKind.LogicalNegation: return(!(bool)operand); case BoundUnaryOperatorKind.OnesComplement: return(~(int)operand); // For now we don't support DereferenceOf or ReferenceOf. default: throw new Exception($"Unexpected unary operator {u.Op}"); } }
public override BoundConstant?VisitUnaryExpression(BoundUnaryExpression node) { var @operator = node.Operator; var operandConstant = node.Operand.Accept(this); if (operandConstant == null) { return(null); } var constant = operandConstant.Value; return(@operator.Kind switch { BoundUnaryOperatorKind.Identity => operandConstant, BoundUnaryOperatorKind.Negation => new BoundConstant(-(int)constant), BoundUnaryOperatorKind.LogicalNegation => new BoundConstant(!(bool)constant), BoundUnaryOperatorKind.BitwiseNegation => new BoundConstant(~(int)constant), _ => throw new ArgumentOutOfRangeException( nameof(node), $"Unknown operator kind '{@operator.Kind}'" ) });
private void EmitUnaryExpression(ILProcessor ilProcessor, BoundUnaryExpression node) { throw new NotImplementedException(); }
private static void WriteBoundUnaryExpression(this IndentedTextWriter writer, BoundUnaryExpression node) { writer.ColorWrite("("); writer.Write(node.Op.GetText()); writer.WriteBoundNode(node.Expression); writer.ColorWrite(")"); }
protected virtual void VisitUnaryExpression(BoundUnaryExpression node) { VisitExpression(node.Expression); }
public virtual void VisitUnaryExpression(BoundUnaryExpression node) => this.DefaultVisit(node);
private object EvaluateUnaryExpression(BoundUnaryExpression expression) { var operand = EvaluateExpression(expression.Operand); switch (expression.Operator.Kind) { case BoundUnaryOperatorKind.Negation: return(-(int)operand); case BoundUnaryOperatorKind.Identity: return((int)operand); case BoundUnaryOperatorKind.LogicalNegation: return(!(bool)operand); case BoundUnaryOperatorKind.PrefixIncrement: var prefixIncrementValue = (int)operand + 1; if (expression.Operand.Kind == BoundNodeKind.VariableExpression) { var variableExpression = (BoundVariableExpression)expression.Operand; _variables[variableExpression.Variable] = prefixIncrementValue; } return(prefixIncrementValue); case BoundUnaryOperatorKind.PrefixDecrement: var prefixDecrementValue = (int)operand - 1; if (expression.Operand.Kind == BoundNodeKind.VariableExpression) { var variableExpression = (BoundVariableExpression)expression.Operand; _variables[variableExpression.Variable] = prefixDecrementValue; } return(prefixDecrementValue); case BoundUnaryOperatorKind.PostfixIncrement: var postfixIncrementValue = (int)operand + 1; if (expression.Operand.Kind == BoundNodeKind.VariableExpression) { var variableExpression = (BoundVariableExpression)expression.Operand; _variables[variableExpression.Variable] = postfixIncrementValue; return(operand); } return(postfixIncrementValue); case BoundUnaryOperatorKind.PostfixDecrement: var postfixDecrementValue = (int)operand - 1; if (expression.Operand.Kind == BoundNodeKind.VariableExpression) { var variableExpression = (BoundVariableExpression)expression.Operand; _variables[variableExpression.Variable] = postfixDecrementValue; return(operand); } return(postfixDecrementValue); case BoundUnaryOperatorKind.OnesCompliment: return(~(int)operand); default: throw new Exception($"Unsupported unary operator {expression.Operator.Kind}."); } }