protected override BoundStatement RewriteForStatement(BoundForStatement node)
{
/*
* {
* let upperBound = <UpperBound>
* <variable> = <lowerBound>
* while <variable> < <UpperBound>
* {
* <statement>
* <variable> = <variable> + 1
* }
* }
*/
var upperBoundSymbol = new VariableSymbol("upperBound", true, node.UpperBound.Type, true);
var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound);
var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol);
var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // LowerBound shouldn't be rewriten?
var variableExpression = new BoundVariableExpression(node.Variable);
var conditionOperator = BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int);
var condition = new BoundBinaryExpression(variableExpression, conditionOperator, upperBoundExpression); // UpperBound shouldn't be rewriten?
var incrementOperator = BoundBinaryOperator.Bind(SyntaxKind.PlusToken, node.Variable.Type, TypeSymbol.Int);
var increment = new BoundBinaryExpression(variableExpression, incrementOperator, new BoundLiteralExpression(1));
var incrementAssignment = new BoundAssignmentExpression(node.Variable, increment);
var incrementStatement = new BoundExpressionStatement(incrementAssignment);
var whileBlockStatement = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Statement, incrementStatement));
var whileStatement = new BoundWhileStatement(condition, whileBlockStatement);
var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(upperBoundDeclaration, variableDeclaration, whileStatement));
return(RewriteStatement(result));
}
private object EvaluateBoundAssignmentExpression(BoundAssignmentExpression a)
{
var value = EvaluateExpression(a.Expression);
_variables[a.Variable] = value;
return(value);
}
protected object EvaluateAssignmentExpression(BoundAssignmentExpression a)
{
var value = EvaluateExpression(a.Expression);
_varialbes[a.Variable] = value;
return(value);
}
private object EvaluateAssignmentExpression(BoundAssignmentExpression a)
{
var value = EvaluateExpression(a.Expression);
Assign(a.Variable, value);
return(value);
}
private object EvaluateAssignmentExpression(BoundAssignmentExpression assignment)
{
var value = EvaluateExpression(assignment.Expression);
variables[assignment.Variable] = value;
return(value);
}
private void EmitAssignmentExpression(ILProcessor ilProcessor, BoundAssignmentExpression node)
{
var variableDefinition = _locals[node.Variable];
EmitExpression(ilProcessor, node.Expression);
ilProcessor.Emit(OpCodes.Dup);
ilProcessor.Emit(OpCodes.Stloc, variableDefinition);
}
private object EvaluateAssignmentExpression(BoundAssignmentExpression expression)
{
var value = EvaluateExpression(expression.Expression);
_variables[expression.Variable] = value;
return(value);
}
private void OutputAssignmentExpression(BoundAssignmentExpression node, string prefix)
{
builder.AddFragment(new OutputFragment(prefix, DefaultColour));
builder.AddFragment(new OutputFragment(node.Identifier.Name, VariableColour));
builder.AddFragment(new OutputFragment(DelimeterString, DefaultColour));
builder.AddFragment(new OutputFragment(node.Identifier.ValueType.Name, TypeColour));
builder.AddFragment(new OutputFragment(" = ", StatementColour));
Output(node.Expression, string.Empty);
}
protected virtual BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression assignment)
{
var expression = RewriteExpression(assignment.Expression);
if (expression == assignment.Expression)
{
return(assignment);
}
return(new BoundAssignmentExpression(assignment.Identifier, expression));
}
protected override BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression assignment)
{
BoundExpression expression = RewriteExpression(assignment.Expression);
if (expression.ValueType != assignment.Identifier.ValueType && TypeConversionSymbol.TryFind(expression.ValueType, assignment.Identifier.ValueType, out var symbol))
{
expression = new BoundInternalTypeConversion(symbol, expression);
}
if (expression == assignment.Expression)
{
return(assignment);
}
return(new BoundAssignmentExpression(assignment.Identifier, expression));
}
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);
}
}
}
}
}
}
protected override BoundExpression RewriteAssignmentExpression(
BoundAssignmentExpression node
)
{
if (node.Left is BoundIndexExpression indexExpression)
{
return(new BoundCallExpression(
node.Syntax,
indexExpression.Setter !,
RewriteExpression(indexExpression.Expression),
ImmutableArray.Create(
RewriteExpression(indexExpression.Index),
RewriteExpression(node.Right)
)
));
}
return(node);
}
private object EvaluateAssignmentExpression(BoundAssignmentExpression assignment)
{
object expression;
if (assignment.Expression.Type == NodeType.FunctionPointer)
{
expression = EvaluateFunctionPointer((BoundFunctionPointer)assignment.Expression, assignment.Identifier.Name);
}
else
{
expression = EvaluateExpression(assignment.Expression);
}
if (expression == null)
{
return(null);
}
Assign(assignment.Identifier, expression);
return(expression);
}
private static void WriteBoundAssignmentExpression(this IndentedTextWriter writer, BoundAssignmentExpression node)
{
writer.WriteVariable(node.Variable !.Name);
writer.WriteSpace();
writer.ColorWrite("=");
writer.WriteSpace();
writer.WriteBoundNode(node.Expression);
}
protected virtual void VisitAssignmentExpression(BoundAssignmentExpression node)
{
VisitExpression(node.Left);
VisitExpression(node.Right);
}
public virtual void VisitAssignmentExpression(BoundAssignmentExpression node) => this.DefaultVisit(node);
protected override BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression node)
{
RewriteStatement(new BoundAssignmentStatement(node.Syntax, node.Left, node.Right));
return(new BoundUnitExpression(node.Syntax));
}
public override void VisitAssignmentExpression(BoundAssignmentExpression node)
{
node.Left.Accept(this);
_writer.WritePunctuation(" = ");
node.Right.Accept(this);
}
