/// <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)); }