private Expression /*!*/ MakeDelegateConstructorCall(Type /*!*/ type, CallArguments /*!*/ args)
{
if (args.Signature.HasBlock)
{
return(Methods.CreateDelegateFromProc.OpCall(
Ast.Constant(type),
AstUtils.Convert(args.GetBlockExpression(), typeof(Proc))
));
}
else
{
// TODO:
throw new NotImplementedError("no block given");
}
}
/// <summary>
/// "yields" to the proc.
/// </summary>
internal void BuildInvoke(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args)
{
Assert.NotNull(metaBuilder, args);
Debug.Assert(!args.Signature.HasBlock);
var convertedTarget = AstUtils.Convert(args.TargetExpression, typeof(BlockParam));
// test for target type:
metaBuilder.AddTypeRestriction(args.Target.GetType(), args.TargetExpression);
metaBuilder.Result = AstFactory.YieldExpression(
args.RubyContext,
args.GetSimpleArgumentExpressions(),
args.GetSplattedArgumentExpression(),
args.GetRhsArgumentExpression(),
args.GetBlockExpression(),
convertedTarget, // block param
Ast.Property(convertedTarget, SelfProperty) // self
);
}
/// <summary>
/// From control flow perspective it "calls" the proc.
/// </summary>
internal static void BuildCall(
MetaObjectBuilder /*!*/ metaBuilder,
Expression /*!*/ procExpression, // proc object
Expression /*!*/ selfExpression, // self passed to the proc
CallArguments /*!*/ args // user arguments passed to the proc
)
{
var bfcVariable = metaBuilder.GetTemporary(typeof(BlockParam), "#bfc");
metaBuilder.Result = Ast.Block(
Ast.Assign(bfcVariable, Methods.CreateBfcForProcCall.OpCall(AstUtils.Convert(procExpression, typeof(Proc)))),
Methods.MethodProcCall.OpCall(bfcVariable,
AstFactory.YieldExpression(
args.RubyContext,
args.GetSimpleArgumentExpressions(),
args.GetSplattedArgumentExpression(),
args.GetRhsArgumentExpression(),
args.GetBlockExpression(),
bfcVariable,
selfExpression
)
)
);
}
