/// <summary>
/// Creates a runtime-bound call site binder.
/// </summary>
public static RubyCallAction /*!*/ Make(RubyContext /*!*/ context, string /*!*/ methodName, RubyCallSignature signature)
{
ContractUtils.RequiresNotNull(context, "context");
ContractUtils.RequiresNotNull(methodName, "methodName");
return(context.MetaBinderFactory.Call(methodName, signature));
}
public static RubyCallAction /*!*/ MakeShared(string /*!*/ methodName, RubyCallSignature signature)
{
// TODO: reduce usage of these sites to minimum
return(RubyMetaBinderFactory.Shared.Call(methodName, signature));
}
internal protected RubyCallAction(RubyContext context, string /*!*/ methodName, RubyCallSignature signature)
: base(context)
{
Assert.NotNull(methodName);
// a virtual call cannot be a super call nor interop call:
Debug.Assert(!signature.IsVirtualCall || !signature.IsSuperCall && !signature.IsInteropCall);
// a super call must have implicit self:
Debug.Assert(!signature.IsSuperCall || signature.HasImplicitSelf);
_methodName = methodName;
_signature = signature;
}
/// <summary>
/// Creates a runtime-bound call site binder.
/// </summary>
public static RubyCallAction /*!*/ Make(RubyContext /*!*/ context, string /*!*/ methodName, int argumentCount)
{
return(Make(context, methodName, RubyCallSignature.Simple(argumentCount)));
}
// Ruby binders:
internal CallArguments(RubyContext context, DynamicMetaObject /*!*/ scopeOrContextOrTargetOrArgArray, DynamicMetaObject /*!*/[] /*!*/ args, RubyCallSignature signature)
{
Assert.NotNull(scopeOrContextOrTargetOrArgArray);
Assert.NotNullItems(args);
ArgumentArray argArray = scopeOrContextOrTargetOrArgArray.Value as ArgumentArray;
if (argArray != null)
{
Debug.Assert(args.Length == 0 && argArray.Count >= 1);
// build meta-objects for arguments wrapped in the array:
args = new DynamicMetaObject[argArray.Count - 1];
for (int i = 0; i < args.Length; i++)
{
args[i] = argArray.GetMetaObject(scopeOrContextOrTargetOrArgArray.Expression, 1 + i);
}
scopeOrContextOrTargetOrArgArray = argArray.GetMetaObject(scopeOrContextOrTargetOrArgArray.Expression, 0);
}
Debug.Assert(signature.HasScope == scopeOrContextOrTargetOrArgArray.Value is RubyScope);
Debug.Assert((context == null && !signature.HasScope) == scopeOrContextOrTargetOrArgArray.Value is RubyContext);
if (context != null)
{
// bound site:
_context = new DynamicMetaObject(AstUtils.Constant(context), BindingRestrictions.Empty, context);
if (signature.HasScope)
{
_scope = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
}
else
{
_target = scopeOrContextOrTargetOrArgArray;
}
}
else if (signature.HasScope)
{
// unbound site with scope:
_context = new DynamicMetaObject(
Methods.GetContextFromScope.OpCall(scopeOrContextOrTargetOrArgArray.Expression), BindingRestrictions.Empty,
((RubyScope)scopeOrContextOrTargetOrArgArray.Value).RubyContext
);
_scope = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
_target = null;
}
else
{
// unbound site with context:
_context = scopeOrContextOrTargetOrArgArray;
_hasScopeOrContextArg = true;
_target = null;
}
Debug.Assert(_target != null || args.Length > 0);
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
Debug.Assert(!signature.HasSplattedArgument || GetSplattedArgument() != null);
}
// interop binders: the target is a Ruby meta-object closed over the context
internal CallArguments(DynamicMetaObject /*!*/ context, DynamicMetaObject /*!*/ target, DynamicMetaObject /*!*/[] /*!*/ args, RubyCallSignature signature)
{
Assert.NotNull(target, context);
Assert.NotNullItems(args);
Debug.Assert(!signature.HasScope && !signature.HasSplattedArgument);
_target = target;
_context = context;
_args = args;
_copyArgsOnWrite = true;
_signature = signature;
}
public static SuperCallAction /*!*/ Make(RubyCallSignature signature, int lexicalScopeId)
{
return(new SuperCallAction(signature, lexicalScopeId));
}
public static SuperCallAction /*!*/ MakeShared(RubyCallSignature signature, int lexicalScopeId)
{
return(RubyMetaBinderFactory.Shared.SuperCall(lexicalScopeId, signature));
}
internal virtual MemberDispatcher GetDispatcher(Type /*!*/ delegateType, RubyCallSignature signature, object target, int version)
{
return(null);
}
private SuperCallAction(RubyCallSignature signature, int lexicalScopeId)
{
_signature = signature;
_lexicalScopeId = lexicalScopeId;
}
internal TracingRubyCallAction(string /*!*/ methodName, RubyCallSignature signature)
: base(null, methodName, signature)
{
}
public static RubyCallAction /*!*/ Make(string /*!*/ methodName, RubyCallSignature signature)
{
return(new RubyCallAction(methodName, signature));
}
protected RubyCallAction(string /*!*/ methodName, RubyCallSignature signature)
{
Assert.NotNull(methodName);
_methodName = methodName;
_signature = signature;
}
public static DynamicMetaObject /*!*/ Bind(DynamicMetaObject /*!*/ context, GetMemberBinder /*!*/ binder, DynamicMetaObject /*!*/ target,
Func <DynamicMetaObject, DynamicMetaObject> /*!*/ fallback)
{
Debug.Assert(fallback != null);
var callArgs = new CallArguments(context, target, DynamicMetaObject.EmptyMetaObjects, RubyCallSignature.Interop(0));
var metaBuilder = new MetaObjectBuilder(target);
if (!RubyCallAction.BuildAccess(metaBuilder, binder.Name, callArgs, false, false))
{
// TODO: error suggestion?
metaBuilder.SetMetaResult(fallback(target), false);
}
return(metaBuilder.CreateMetaObject(binder));
}
public static SuperCallAction /*!*/ Make(int argumentCount, int lexicalScopeId)
{
ContractUtils.Requires(argumentCount >= 0, "argumentCount");
return(new SuperCallAction(RubyCallSignature.WithScope(argumentCount), lexicalScopeId));
}
private static VisibilityContext GetVisibilityContext(RubyCallSignature callSignature, RubyScope scope)
{
return(callSignature.HasImplicitSelf || !callSignature.HasScope ?
new VisibilityContext(callSignature.IsInteropCall ? RubyMethodAttributes.Public : RubyMethodAttributes.VisibilityMask) :
new VisibilityContext(scope.SelfImmediateClass));
}
public static SuperCallAction /*!*/ Make(RubyContext /*!*/ context, RubyCallSignature signature, int lexicalScopeId)
{
ContractUtils.RequiresNotNull(context, "context");
return(context.MetaBinderFactory.SuperCall(lexicalScopeId, signature));
}
