/// <summary> /// Creates a lambda Proc that has the same target, context and self object as this block. /// Doesn't preserve the class of the Proc. /// </summary> public Proc /*!*/ ToLambda(RubyLambdaMethodInfo method) { Proc result = new Proc(this); result.Kind = ProcKind.Lambda; result._method = method; return(result); }
/// <summary> /// Returns /// -1 if there is no method or block-method scope, /// 0 if the target scope is a method scope, /// id > 0 of the target lambda for block-method scopes. /// </summary> internal int GetSuperCallTarget(out RubyModule declaringModule, out string /*!*/ methodName, out RubyScope targetScope) { RubyScope scope = this; while (true) { Debug.Assert(scope != null); switch (scope.Kind) { case ScopeKind.Method: RubyMethodScope methodScope = (RubyMethodScope)scope; // See RubyOps.DefineMethod for why we can use Method here. declaringModule = methodScope.DeclaringModule; methodName = methodScope.DefinitionName; targetScope = scope; return(0); case ScopeKind.BlockMethod: RubyLambdaMethodInfo info = ((RubyBlockScope)scope).BlockFlowControl.Proc.Method; Debug.Assert(info != null); declaringModule = info.DeclaringModule; methodName = info.DefinitionName; targetScope = scope; return(info.Id); case ScopeKind.TopLevel: declaringModule = null; methodName = null; targetScope = null; return(-1); } scope = scope.Parent; } }
public static BlockParam /*!*/ CreateBfcForMethodProcCall(Proc /*!*/ proc, RubyLambdaMethodInfo /*!*/ method) { Assert.NotNull(proc, method); return(new BlockParam(proc, BlockCallerKind.Call, false, method.DeclaringModule, method.DefinitionName)); }