|
private Return ( System.Linq.Expressions expression ) : |
||
| expression | System.Linq.Expressions | |
| return | ||
internal static MSA.Expression /*!*/ TransformRetry(AstGenerator /*!*/ gen)
{
// eval:
if (gen.CompilerOptions.IsEval)
{
return(Methods.EvalRetry.OpCall(gen.CurrentRfcVariable));
}
// rescue clause:
if (gen.CurrentRescue != null)
{
return(Ast.Block(
Ast.Assign(gen.CurrentRescue.RetryingVariable, Ast.Constant(true)),
Ast.Continue(gen.CurrentRescue.ContinueLabel),
Ast.Empty()
));
}
// block:
if (gen.CurrentBlock != null)
{
return(gen.Return(Methods.BlockRetry.OpCall(gen.CurrentBlock.BfcVariable)));
}
// primary frame:
return(gen.Return(Methods.MethodRetry.OpCall(gen.CurrentRfcVariable, gen.MakeMethodBlockParameterRead())));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Break
internal override MSA.Expression /*!*/ Transform(AstGenerator /*!*/ gen)
{
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval)
{
return(Methods.EvalBreak.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue)));
}
// loop:
if (gen.CurrentLoop != null)
{
return(Ast.Block(
Ast.Assign(
gen.CurrentLoop.ResultVariable,
Ast.Convert(transformedReturnValue, gen.CurrentLoop.ResultVariable.Type)
),
Ast.Break(gen.CurrentLoop.BreakLabel),
AstUtils.Empty()
));
}
// block:
if (gen.CurrentBlock != null)
{
return(gen.Return(Methods.BlockBreak.OpCall(gen.CurrentBlock.BfcVariable, AstUtils.Box(transformedReturnValue))));
}
// primary frame:
return(Methods.MethodBreak.OpCall(AstUtils.Box(transformedReturnValue)));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Next
internal override MSA.Expression /*!*/ Transform(AstGenerator /*!*/ gen)
{
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval)
{
return(Methods.EvalNext.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue)));
}
// loop:
if (gen.CurrentLoop != null)
{
return(Ast.Block(
transformedReturnValue, // evaluate for side-effects
Ast.Continue(gen.CurrentLoop.ContinueLabel),
AstUtils.Empty()
));
}
// block:
if (gen.CurrentBlock != null)
{
return(gen.Return(transformedReturnValue));
}
// method:
return(Methods.MethodNext.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue)));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Next
/*!*/
internal override MSA.Expression Transform(AstGenerator/*!*/ gen)
{
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval) {
return Methods.EvalNext.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue));
}
// loop:
if (gen.CurrentLoop != null) {
return Ast.Block(
transformedReturnValue, // evaluate for side-effects
Ast.Continue(gen.CurrentLoop.ContinueLabel),
AstUtils.Empty()
);
}
// block:
if (gen.CurrentBlock != null) {
return gen.Return(transformedReturnValue);
}
// method:
return Methods.MethodNext.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Break
internal override MSA.Expression/*!*/ Transform(AstGenerator/*!*/ gen) {
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval) {
return Methods.EvalBreak.OpCall(gen.CurrentRfcVariable, AstFactory.Box(transformedReturnValue));
}
// loop:
if (gen.CurrentLoop != null) {
return Ast.Block(
Ast.Assign(
gen.CurrentLoop.ResultVariable,
Ast.Convert(transformedReturnValue, gen.CurrentLoop.ResultVariable.Type)
),
Ast.Break(gen.CurrentLoop.BreakLabel),
Ast.Empty()
);
}
// block:
if (gen.CurrentBlock != null) {
return gen.Return(Methods.BlockBreak.OpCall(gen.CurrentBlock.BfcVariable, AstFactory.Box(transformedReturnValue)));
}
// primary frame:
return Methods.MethodBreak.OpCall(AstFactory.Box(transformedReturnValue));
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Return
internal override MSA.Expression/*!*/ Transform(AstGenerator/*!*/ gen) {
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval) {
return gen.Return(Methods.EvalReturn.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue)));
}
// block:
if (gen.CurrentBlock != null) {
return gen.Return(Methods.BlockReturn.OpCall(gen.CurrentBlock.BfcVariable, AstUtils.Box(transformedReturnValue)));
}
// method:
return gen.Return(transformedReturnValue);
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Yield
internal override MSA.Expression/*!*/ TransformRead(AstGenerator/*!*/ gen) {
MSA.Expression bfcVariable = gen.CurrentScope.DefineHiddenVariable("#yielded-bfc", typeof(BlockParam));
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#result", typeof(object));
MSA.Expression postYield;
if (gen.CompilerOptions.IsEval) {
// eval:
postYield = Methods.EvalYield.OpCall(gen.CurrentScopeVariable, bfcVariable, resultVariable);
} else if (gen.CurrentBlock != null) {
// block:
postYield = Methods.BlockYield.OpCall(gen.CurrentScopeVariable, gen.CurrentBlock.BfcVariable, bfcVariable, resultVariable);
} else {
// method:
postYield = Methods.MethodYield.OpCall(gen.CurrentScopeVariable, bfcVariable, resultVariable);
}
return new AstBlock {
gen.DebugMarker("#RB: yield begin"),
Ast.Assign(bfcVariable, Methods.CreateBfcForYield.OpCall(gen.MakeMethodBlockParameterRead())),
Ast.Assign(
resultVariable,
(Arguments ?? Arguments.Empty).TransformToYield(gen, bfcVariable, gen.MakeMethodBlockParameterSelfRead())
),
AstUtils.IfThen(postYield, gen.Return(resultVariable)),
gen.DebugMarker("#RB: yield end"),
resultVariable
};
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Return
internal override MSA.Expression /*!*/ Transform(AstGenerator /*!*/ gen)
{
MSA.Expression transformedReturnValue = TransformReturnValue(gen);
// eval:
if (gen.CompilerOptions.IsEval)
{
return(gen.Return(Methods.EvalReturn.OpCall(gen.CurrentScopeVariable, AstUtils.Box(transformedReturnValue))));
}
// block:
if (gen.CurrentBlock != null)
{
return(gen.Return(Methods.BlockReturn.OpCall(gen.CurrentBlock.BfcVariable, AstUtils.Box(transformedReturnValue))));
}
// method:
return(gen.Return(transformedReturnValue));
}
/// <summary>
/// Transform and handle the result according to the specified result operation.
/// </summary>
internal virtual MSA.Expression/*!*/ TransformResult(AstGenerator/*!*/ gen, ResultOperation resultOperation) {
MSA.Expression resultExpression = TransformRead(gen);
MSA.Expression statement;
if (resultOperation.Variable != null) {
statement = Ast.Assign(resultOperation.Variable, Ast.Convert(resultExpression, resultOperation.Variable.Type));
} else {
statement = gen.Return(resultExpression);
}
return gen.AddDebugInfo(statement, Location);
}
internal static MSA.Expression/*!*/ TransformRetry(AstGenerator/*!*/ gen) {
// eval:
if (gen.CompilerOptions.IsEval) {
return Methods.EvalRetry.OpCall(gen.CurrentScopeVariable);
}
// rescue clause:
if (gen.CurrentRescue != null) {
return Ast.Block(
Ast.Assign(gen.CurrentRescue.RetryingVariable, AstUtils.Constant(true)),
Ast.Goto(gen.CurrentRescue.RetryLabel, typeof(void))
);
}
// block:
if (gen.CurrentBlock != null) {
return gen.Return(Methods.BlockRetry.OpCall(gen.CurrentBlock.BfcVariable));
}
// primary frame:
return gen.Return(Methods.MethodRetry.OpCall(gen.CurrentScopeVariable, gen.MakeMethodBlockParameterRead()));
}
/// <summary>
/// Transform and handle the result according to the specified result operation.
/// </summary>
internal virtual MSA.Expression /*!*/ TransformResult(AstGenerator /*!*/ gen, ResultOperation resultOperation)
{
MSA.Expression resultExpression = TransformRead(gen);
MSA.Expression statement;
if (resultOperation.Variable != null)
{
statement = Ast.Assign(resultOperation.Variable, Ast.Convert(resultExpression, resultOperation.Variable.Type));
}
else
{
statement = gen.Return(resultExpression);
}
return(gen.AddDebugInfo(statement, Location));
}
internal static MSA.Expression /*!*/ MakeCallWithBlockRetryable(AstGenerator /*!*/ gen, MSA.Expression /*!*/ invoke,
MSA.Expression blockArgVariable, MSA.Expression transformedBlock, bool isBlockDefinition)
{
Assert.NotNull(invoke);
Debug.Assert((blockArgVariable == null) == (transformedBlock == null));
// see Ruby Language.doc/Control Flow Implementation/Method Call With a Block
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#method-result", typeof(object));
MSA.ParameterExpression evalUnwinder;
MSA.LabelTarget retryLabel = Ast.Label("retry");
var result = new AstBlock {
Ast.Assign(blockArgVariable, Ast.Convert(transformedBlock, blockArgVariable.Type)),
Ast.Label(retryLabel),
(isBlockDefinition) ? Methods.InitializeBlock.OpCall(blockArgVariable) : null,
AstUtils.Try(
Ast.Assign(resultVariable, invoke)
).Catch(evalUnwinder = Ast.Parameter(typeof(EvalUnwinder), "#u"),
Ast.Assign(
resultVariable,
Ast.Field(evalUnwinder, EvalUnwinder.ReturnValueField)
)
),
Ast.IfThen(Ast.TypeEqual(resultVariable, typeof(BlockReturnResult)),
Ast.IfThenElse(Methods.IsRetrySingleton.OpCall(resultVariable),
// retry:
AstUtils.IfThenElse(Ast.Equal(gen.MakeMethodBlockParameterRead(), blockArgVariable),
RetryStatement.TransformRetry(gen),
Ast.Goto(retryLabel)
),
// return:
gen.Return(ReturnStatement.Propagate(gen, resultVariable))
)
),
resultVariable
};
return(result);
}
// see Ruby Language.doc/Runtime/Control Flow Implementation/Yield
internal override MSA.Expression /*!*/ TransformRead(AstGenerator /*!*/ gen)
{
MSA.Expression bfcVariable = gen.CurrentScope.DefineHiddenVariable("#yielded-bfc", typeof(BlockParam));
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#result", typeof(object));
MSA.Expression evalUnwinder = gen.CurrentScope.DefineHiddenVariable("#unwinder", typeof(EvalUnwinder));
MSA.Expression postYield;
if (gen.CompilerOptions.IsEval)
{
// eval:
postYield = Methods.EvalYield.OpCall(gen.CurrentRfcVariable, bfcVariable, resultVariable);
}
else if (gen.CurrentBlock != null)
{
// block:
postYield = Methods.BlockYield.OpCall(gen.CurrentRfcVariable, gen.CurrentBlock.BfcVariable, bfcVariable, resultVariable);
}
else
{
// method:
postYield = Methods.MethodYield.OpCall(gen.CurrentRfcVariable, bfcVariable, resultVariable);
}
return(AstFactory.Block(
gen.DebugMarker("#RB: yield begin"),
Ast.Assign(bfcVariable, Methods.CreateBfcForYield.OpCall(gen.MakeMethodBlockParameterRead())),
Ast.Assign(resultVariable, (Arguments ?? Arguments.Empty).TransformToYield(gen, bfcVariable,
Ast.Property(AstUtils.Convert(gen.MakeMethodBlockParameterRead(), typeof(Proc)), Proc.SelfProperty)
)),
AstUtils.IfThen(postYield, gen.Return(resultVariable)),
gen.DebugMarker("#RB: yield end"),
resultVariable
));
}
internal override MSA.Expression /*!*/ Transform(AstGenerator /*!*/ gen)
{
MSA.Expression parentScope = gen.CurrentScopeVariable;
ScopeBuilder scope = new ScopeBuilder();
// define hidden parameters and RHS-placeholders (#1..#n will be used as RHS of a parallel assignment):
MSA.Expression blockParameter, selfParameter;
MSA.ParameterExpression[] parameters = DefineParameters(out selfParameter, out blockParameter);
MSA.Expression scopeVariable = scope.DefineHiddenVariable("#scope", typeof(RubyBlockScope));
MSA.LabelTarget redoLabel = Ast.Label();
gen.EnterBlockDefinition(
scope,
blockParameter,
selfParameter,
scopeVariable,
redoLabel
);
if (_definedScope != null)
{
_definedScope.TransformLocals(scope);
}
MSA.Expression paramInit = MakeParametersInitialization(gen, parameters);
MSA.ParameterExpression blockUnwinder = scope.DefineHiddenVariable("#unwinder", typeof(BlockUnwinder));
MSA.Expression loop = AstFactory.Infinite(null, redoLabel,
AstUtils.Try(
gen.TransformStatements(_body, ResultOperation.Return)
).Catch(blockUnwinder,
// redo:
AstUtils.IfThen(Ast.Field(blockUnwinder, BlockUnwinder.IsRedoField), Ast.Continue(redoLabel)),
// next:
gen.Return(Ast.Field(blockUnwinder, BlockUnwinder.ReturnValueField))
)
);
if (gen.TraceEnabled)
{
int firstStatementLine = _body.Count > 0 ? _body[0].Location.Start.Line : Location.End.Line;
int lastStatementLine = _body.Count > 0 ? _body[_body.Count - 1].Location.End.Line : Location.End.Line;
loop = Ast.TryFinally(
Ast.Block(
Methods.TraceBlockCall.OpCall(scopeVariable, blockParameter, Ast.Convert(Ast.Constant(gen.SourceUnit.Path), typeof(string)), Ast.Constant(firstStatementLine)),
loop
),
Methods.TraceBlockReturn.OpCall(scopeVariable, blockParameter, Ast.Convert(Ast.Constant(gen.SourceUnit.Path), typeof(string)), Ast.Constant(lastStatementLine))
);
}
MSA.Expression body = Ast.Block(
Ast.Assign(scopeVariable,
Methods.CreateBlockScope.OpCall(scope.VisibleVariables(), parentScope, blockParameter, selfParameter)
),
paramInit,
loop,
Ast.Empty()
);
body = gen.AddReturnTarget(scope.CreateScope(body));
gen.LeaveBlockDefinition();
int parameterCount = _parameters.LeftValues.Count;
var attributes = _parameters.GetBlockSignatureAttributes();
return(Methods.DefineBlock.OpCall(
gen.CurrentScopeVariable,
gen.CurrentRfcVariable,
gen.CurrentSelfVariable,
Ast.Lambda(
BlockDispatcher.GetDelegateType(parameterCount, attributes),
body,
gen.EncodeMethodName(gen.CurrentMethod.MethodName, Location),
new ReadOnlyCollection <MSA.ParameterExpression>(parameters)
),
Ast.Constant(parameterCount),
Ast.Constant(attributes)
));
}
internal MSA.Expression /*!*/ Transform(AstGenerator /*!*/ gen, bool isLambda)
{
ScopeBuilder scope = DefineLocals(gen.CurrentScope);
// define hidden parameters and RHS-placeholders (#1..#n will be used as RHS of a parallel assignment):
MSA.ParameterExpression blockParameter, selfParameter;
var parameters = DefineParameters(out selfParameter, out blockParameter);
MSA.ParameterExpression scopeVariable = scope.DefineHiddenVariable("#scope", typeof(RubyBlockScope));
MSA.LabelTarget redoLabel = Ast.Label();
gen.EnterBlockDefinition(
scope,
blockParameter,
selfParameter,
scopeVariable,
redoLabel
);
MSA.Expression paramInit = MakeParametersInitialization(gen, parameters);
MSA.ParameterExpression blockUnwinder, filterVariable;
MSA.Expression traceCall, traceReturn;
if (gen.TraceEnabled)
{
int firstStatementLine = _body.Count > 0 ? _body.First.Location.Start.Line : Location.End.Line;
int lastStatementLine = _body.Count > 0 ? _body.Last.Location.End.Line : Location.End.Line;
traceCall = Methods.TraceBlockCall.OpCall(scopeVariable, blockParameter, gen.SourcePathConstant, AstUtils.Constant(firstStatementLine));
traceReturn = Methods.TraceBlockReturn.OpCall(scopeVariable, blockParameter, gen.SourcePathConstant, AstUtils.Constant(lastStatementLine));
}
else
{
traceCall = traceReturn = Ast.Empty();
}
MSA.Expression body = AstUtils.Try(
paramInit,
traceCall,
Ast.Label(redoLabel),
AstUtils.Try(
gen.TransformStatements(_body, ResultOperation.Return)
).Catch(blockUnwinder = Ast.Parameter(typeof(BlockUnwinder), "#u"),
// redo:
AstUtils.IfThen(Ast.Field(blockUnwinder, BlockUnwinder.IsRedoField), Ast.Goto(redoLabel)),
// next:
gen.Return(Ast.Field(blockUnwinder, BlockUnwinder.ReturnValueField))
)
).Filter(filterVariable = Ast.Parameter(typeof(Exception), "#e"),
Methods.FilterBlockException.OpCall(scopeVariable, filterVariable)
).Finally(
traceReturn,
Ast.Empty()
);
body = gen.AddReturnTarget(
scope.CreateScope(
scopeVariable,
Methods.CreateBlockScope.OpCall(new AstExpressions {
scope.MakeLocalsStorage(),
scope.GetVariableNamesExpression(),
blockParameter,
selfParameter,
EnterInterpretedFrameExpression.Instance
}),
body
)
);
gen.LeaveBlockDefinition();
int parameterCount = ParameterCount;
var attributes = _parameters.GetBlockSignatureAttributes();
var dispatcher = Ast.Constant(
BlockDispatcher.Create(parameterCount, attributes, gen.SourcePath, Location.Start.Line), typeof(BlockDispatcher)
);
return(Ast.Coalesce(
(isLambda ? Methods.InstantiateLambda : Methods.InstantiateBlock).OpCall(gen.CurrentScopeVariable, gen.CurrentSelfVariable, dispatcher),
(isLambda ? Methods.DefineLambda : Methods.DefineBlock).OpCall(gen.CurrentScopeVariable, gen.CurrentSelfVariable, dispatcher,
BlockDispatcher.CreateLambda(
body,
RubyStackTraceBuilder.EncodeMethodName(gen.CurrentMethod.MethodName, gen.SourcePath, Location, gen.DebugMode),
parameters,
parameterCount,
attributes
)
)
));
}
internal MSA.Expression/*!*/ Transform(AstGenerator/*!*/ gen, bool isLambda) {
ScopeBuilder scope = DefineLocals(gen.CurrentScope);
// define hidden parameters and RHS-placeholders (#1..#n will be used as RHS of a parallel assignment):
MSA.ParameterExpression blockParameter, selfParameter;
var parameters = DefineParameters(out selfParameter, out blockParameter);
MSA.ParameterExpression scopeVariable = scope.DefineHiddenVariable("#scope", typeof(RubyBlockScope));
MSA.LabelTarget redoLabel = Ast.Label();
gen.EnterBlockDefinition(
scope,
blockParameter,
selfParameter,
scopeVariable,
redoLabel
);
MSA.Expression paramInit = MakeParametersInitialization(gen, parameters);
MSA.ParameterExpression blockUnwinder, filterVariable;
MSA.Expression traceCall, traceReturn;
if (gen.TraceEnabled) {
int firstStatementLine = _body.Count > 0 ? _body.First.Location.Start.Line : Location.End.Line;
int lastStatementLine = _body.Count > 0 ? _body.Last.Location.End.Line : Location.End.Line;
traceCall = Methods.TraceBlockCall.OpCall(scopeVariable, blockParameter, gen.SourcePathConstant, AstUtils.Constant(firstStatementLine));
traceReturn = Methods.TraceBlockReturn.OpCall(scopeVariable, blockParameter, gen.SourcePathConstant, AstUtils.Constant(lastStatementLine));
} else {
traceCall = traceReturn = Ast.Empty();
}
MSA.Expression body = AstUtils.Try(
paramInit,
traceCall,
Ast.Label(redoLabel),
AstUtils.Try(
gen.TransformStatements(_body, ResultOperation.Return)
).Catch(blockUnwinder = Ast.Parameter(typeof(BlockUnwinder), "#u"),
// redo:
AstUtils.IfThen(Ast.Field(blockUnwinder, BlockUnwinder.IsRedoField), Ast.Goto(redoLabel)),
// next:
gen.Return(Ast.Field(blockUnwinder, BlockUnwinder.ReturnValueField))
)
).Filter(filterVariable = Ast.Parameter(typeof(Exception), "#e"),
Methods.FilterBlockException.OpCall(scopeVariable, filterVariable)
).Finally(
traceReturn,
Ast.Empty()
);
body = gen.AddReturnTarget(
scope.CreateScope(
scopeVariable,
Methods.CreateBlockScope.OpCall(new AstExpressions {
scope.MakeLocalsStorage(),
scope.GetVariableNamesExpression(),
blockParameter,
selfParameter,
EnterInterpretedFrameExpression.Instance
}),
body
)
);
gen.LeaveBlockDefinition();
int parameterCount = ParameterCount;
var attributes = _parameters.GetBlockSignatureAttributes();
var dispatcher = Ast.Constant(
BlockDispatcher.Create(parameterCount, attributes, gen.SourcePath, Location.Start.Line), typeof(BlockDispatcher)
);
return Ast.Coalesce(
(isLambda ? Methods.InstantiateLambda : Methods.InstantiateBlock).OpCall(gen.CurrentScopeVariable, gen.CurrentSelfVariable, dispatcher),
(isLambda ? Methods.DefineLambda : Methods.DefineBlock).OpCall(gen.CurrentScopeVariable, gen.CurrentSelfVariable, dispatcher,
BlockDispatcher.CreateLambda(
body,
RubyStackTraceBuilder.EncodeMethodName(gen.CurrentMethod.MethodName, gen.SourcePath, Location, gen.DebugMode),
parameters,
parameterCount,
attributes
)
)
);
}
internal static MSA.Expression/*!*/ MakeCallWithBlockRetryable(AstGenerator/*!*/ gen, MSA.Expression/*!*/ invoke,
MSA.Expression blockArgVariable, MSA.Expression transformedBlock, bool isBlockDefinition) {
Assert.NotNull(invoke);
Debug.Assert((blockArgVariable == null) == (transformedBlock == null));
// see Ruby Language.doc/Control Flow Implementation/Method Call With a Block
MSA.Expression resultVariable = gen.CurrentScope.DefineHiddenVariable("#method-result", typeof(object));
MSA.ParameterExpression evalUnwinder;
MSA.LabelTarget retryLabel = Ast.Label("retry");
var result = new AstBlock {
Ast.Assign(blockArgVariable, Ast.Convert(transformedBlock, blockArgVariable.Type)),
Ast.Label(retryLabel),
(isBlockDefinition) ? Methods.InitializeBlock.OpCall(blockArgVariable) : null,
AstUtils.Try(
Ast.Assign(resultVariable, invoke)
).Catch(evalUnwinder = Ast.Parameter(typeof(EvalUnwinder), "#u"),
Ast.Assign(
resultVariable,
Ast.Field(evalUnwinder, EvalUnwinder.ReturnValueField)
)
),
Ast.IfThen(Ast.TypeEqual(resultVariable, typeof(BlockReturnResult)),
Ast.IfThenElse(Methods.IsRetrySingleton.OpCall(resultVariable),
// retry:
AstUtils.IfThenElse(Ast.Equal(gen.MakeMethodBlockParameterRead(), blockArgVariable),
RetryStatement.TransformRetry(gen),
Ast.Goto(retryLabel)
),
// return:
gen.Return(ReturnStatement.Propagate(gen, resultVariable))
)
),
resultVariable
};
return result;
}
internal override MSA.Expression/*!*/ Transform(AstGenerator/*!*/ gen) {
MSA.Expression parentScope = gen.CurrentScopeVariable;
ScopeBuilder scope = new ScopeBuilder();
// define hidden parameters and RHS-placeholders (#1..#n will be used as RHS of a parallel assignment):
MSA.Expression blockParameter, selfParameter;
MSA.ParameterExpression[] parameters = DefineParameters(out selfParameter, out blockParameter);
MSA.ParameterExpression scopeVariable = scope.DefineHiddenVariable("#scope", typeof(RubyBlockScope));
MSA.LabelTarget redoLabel = Ast.Label();
gen.EnterBlockDefinition(
scope,
blockParameter,
selfParameter,
scopeVariable,
redoLabel
);
if (_definedScope != null) {
_definedScope.TransformLocals(scope);
}
MSA.Expression paramInit = MakeParametersInitialization(gen, parameters);
MSA.ParameterExpression blockUnwinder = scope.DefineHiddenVariable("#unwinder", typeof(BlockUnwinder));
MSA.ParameterExpression filterVariable = scope.DefineHiddenVariable("#e", typeof(Exception));
MSA.Expression traceCall, traceReturn;
if (gen.TraceEnabled) {
int firstStatementLine = _body.Count > 0 ? _body.First.Location.Start.Line : Location.End.Line;
int lastStatementLine = _body.Count > 0 ? _body.Last.Location.End.Line : Location.End.Line;
traceCall = Methods.TraceBlockCall.OpCall(scopeVariable, blockParameter, Ast.Convert(AstUtils.Constant(gen.SourceUnit.Path), typeof(string)), AstUtils.Constant(firstStatementLine));
traceReturn = Methods.TraceBlockReturn.OpCall(scopeVariable, blockParameter, Ast.Convert(AstUtils.Constant(gen.SourceUnit.Path), typeof(string)), AstUtils.Constant(lastStatementLine));
} else {
traceCall = traceReturn = Ast.Empty();
}
MSA.Expression body = AstUtils.Try(
Ast.Assign(scopeVariable,
Methods.CreateBlockScope.OpCall(
scope.VisibleVariables(), parentScope, blockParameter, selfParameter, EnterInterpretedFrameExpression.Instance
)
),
paramInit,
traceCall,
Ast.Label(redoLabel),
AstUtils.Try(
gen.TransformStatements(_body, ResultOperation.Return)
).Catch(blockUnwinder,
// redo:
AstUtils.IfThen(Ast.Field(blockUnwinder, BlockUnwinder.IsRedoField), Ast.Goto(redoLabel)),
// next:
gen.Return(Ast.Field(blockUnwinder, BlockUnwinder.ReturnValueField))
)
).Filter(filterVariable,
Methods.FilterBlockException.OpCall(scopeVariable, filterVariable)
).Finally(
traceReturn,
Methods.LeaveBlockFrame.OpCall(scopeVariable),
LeaveInterpretedFrameExpression.Instance
);
body = gen.AddReturnTarget(scope.CreateScope(body));
gen.LeaveBlockDefinition();
int parameterCount = _parameters.LeftValues.Count;
var attributes = _parameters.GetBlockSignatureAttributes();
return Methods.DefineBlock.OpCall(
gen.CurrentScopeVariable,
gen.CurrentRfcVariable,
gen.CurrentSelfVariable,
BlockDispatcher.CreateLambda(
body,
RubyExceptionData.EncodeMethodName(gen.SourceUnit, gen.CurrentMethod.MethodName, Location),
new ReadOnlyCollection<MSA.ParameterExpression>(parameters),
parameterCount,
attributes
),
AstUtils.Constant(parameterCount),
AstUtils.Constant(attributes)
);
}