public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var overloads = GetMethods(binder.Name);
if (overloads == null)
{
return(binder.FallbackInvokeMember(this, args));
}
if (Disposed)
{
return(new DynamicMetaObject(ThrowObjectDisposedException(typeof(object)), BindingRestrictions.GetInstanceRestriction(Expression, Value)));
}
var applicable = overloads.Where(o => (o.IsStatic == !HasSelf) && o.ArgumentTypes.Count == args.Length).ToArray();
if (applicable.Length == 0)
{
return(binder.FallbackInvokeMember(this, args));
}
TryInvokeMember invoke = info.TryInvokeMember;
var value = Expression.Parameter(typeof(object), "value");
var fallback = binder.FallbackInvokeMember(this, args);
var call = Expression.Block(
new[] { value },
Expression.Condition(
test: Expression.Call(Expression.Constant(info), invoke.GetMethodInfo(), GetSelf(), Expression.Constant(applicable), Expression.Constant(args), value),
ifTrue: value,
ifFalse: fallback.Expression)
);
return(new DynamicMetaObject(call, BindingRestrictions.GetInstanceRestriction(Expression, Value)));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
Logger.Log(LogLevel.Debug, null, "BindInvokeMember");
var argValues = Expression.NewArrayInit(typeof(object), args.Select(x => Expression.Convert(x.Expression, typeof(Object))));
var argNames = Expression.Constant(binder.CallInfo.ArgumentNames, typeof(IEnumerable <string>));
var argNamedEnumerable = Expression.Call(typeof(Arguments).GetMethod("From"), argValues, argNames);
var binderDefault = binder.FallbackInvokeMember(this, args);
var missingLambda = Expression.Lambda(Expression.Call(
GetClayBehavior(),
IClayBehavior_InvokeMemberMissing,
Expression.Lambda(binderDefault.Expression),
GetLimitedSelf(),
Expression.Constant(binder.Name, typeof(string)),
argNamedEnumerable));
var call = Expression.Call(
GetClayBehavior(),
IClayBehavior_InvokeMember,
missingLambda,
GetLimitedSelf(),
Expression.Constant(binder.Name, typeof(string)),
argNamedEnumerable);
var dynamicSuggestion = new DynamicMetaObject(
call, BindingRestrictions.GetTypeRestriction(Expression, LimitType).Merge(binderDefault.Restrictions));
return(binder.FallbackInvokeMember(this, args, dynamicSuggestion));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
// get the default binding the language would return if we weren't involved
// This will either access a property on MyDynamicObject or it will report
// an error in a language appropriate manner.
DynamicMetaObject errorSuggestion = binder.FallbackInvokeMember(this, args);
// run through the plugins and replace our current rule. Running through
// the list forward means the last plugin has the highest precedence because
// it may throw away the previous rules if it succeeds.
for (int i = 0; i < Value._plugins.Length; i++)
{
var pluginDo = DynamicMetaObject.Create(Value._plugins[i],
Expression.Call(
typeof(MyDynamicObjectOps).GetMethod("GetPlugin"),
Expression,
Expression.Constant(i)
)
);
errorSuggestion = binder.FallbackInvokeMember(pluginDo, args, errorSuggestion);
}
// Do we want DynamicMetaObject to have precedence? If so then we can do
// one more bind passing what we've produced so far as the rule. Or if the
// plugins have precedence we could just return the value. We'll do that
// here based upon the member name.
if (binder.Name == "Foo")
{
return(binder.FallbackInvokeMember(this, args, errorSuggestion));
}
return(errorSuggestion);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
// VbGetBinder calls this method when you read a dynamic property from VB code
var binderDefault = binder.FallbackInvokeMember(this, args);
var expression = Expression.Convert(GetIndexExpression(binder.Name), typeof(object));
var dynamicSuggestion = new DynamicMetaObject(expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)
.Merge(binderDefault.Restrictions));
return(binder.FallbackInvokeMember(this, args, dynamicSuggestion));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
// Generate a tree like:
//
// {
// object result;
// TryInvokeMember(payload, out result)
// ? result
// : TryGetMember(payload, out result)
// ? FallbackInvoke(result)
// : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
Fallback fallback = e => binder.FallbackInvokeMember(this, args, e);
var call = BuildCallMethodWithResult(
"TryInvokeMember",
binder,
GetExpressions(args),
BuildCallMethodWithResult(
"TryGetMember",
new GetBinderAdapter(binder),
NoArgs,
fallback(null),
(e) => binder.FallbackInvoke(e, args, null)
),
null
);
return(fallback(call));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
return(DynamicTryGetMember(binder.Name,
binder.FallbackInvokeMember(this, args).Expression,
(tmp) => binder.FallbackInvoke(new DynamicMetaObject(tmp, BindingRestrictions.Empty), args, null).Expression
));
}
public override DynamicMetaObject/*!*/ BindInvokeMember(InvokeMemberBinder/*!*/ action, DynamicMetaObject/*!*/[]/*!*/ args) {
DynamicMetaObject errorSuggestion = null;
if (_baseMetaObject != null) {
errorSuggestion = _baseMetaObject.BindInvokeMember(action, args);
}
CodeContext context = BinderState.GetBinderState(action).Context;
IPythonObject sdo = Value;
PythonTypeSlot foundSlot;
if (TryGetGetAttribute(context, sdo.PythonType, out foundSlot)) {
// we'll always fetch the value, go ahead and invoke afterwards.
return BindingHelpers.GenericCall(action, this, args);
}
bool isOldStyle;
bool systemTypeResolution;
foundSlot = FindSlot(context, action.Name, sdo, out isOldStyle, out systemTypeResolution);
if (foundSlot != null && !systemTypeResolution) {
// we found the member in the type dictionary, not a .NET type, go ahead and
// do the get & invoke.
return BindingHelpers.GenericCall(action, this, args);
}
// it's a normal .NET member, let the calling language handle it how it usually does
return action.FallbackInvokeMember(this, args, errorSuggestion);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (IsOverridden("TryInvokeMember"))
{
return(CallMethodWithResult("TryInvokeMember", binder, GetArgArray(args), (e) => binder.FallbackInvokeMember(this, args, e)));
}
else if (IsOverridden("TryGetMember"))
{
// Generate a tree like:
//
// {
// object result;
// TryGetMember(payload, out result) ? FallbackInvoke(result) : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
return(CallMethodWithResult(
"TryGetMember", new GetBinderAdapter(binder), NoArgs,
(e) => binder.FallbackInvokeMember(this, args, e),
(e) => binder.FallbackInvoke(e, args, null)
));
}
return(base.BindInvokeMember(binder, args));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var expression = this.FindMethod(binder, args);
var restrictions = BindingRestrictions.GetTypeRestriction(this.Expression, this.LimitType);
var errorSuggestion = new DynamicMetaObject(expression, restrictions);
return(binder.FallbackInvokeMember(this, args, errorSuggestion));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (!this.IsOverridden("TryInvokeMember"))
{
return(base.BindInvokeMember(binder, args));
}
DynamicProxyMetaObject <T> .Fallback fallback = (DynamicMetaObject e) => binder.FallbackInvokeMember(this, args, e);
return(this.BuildCallMethodWithResult("TryInvokeMember", binder, DynamicProxyMetaObject <T> .GetArgArray(args), this.BuildCallMethodWithResult("TryGetMember", new DynamicProxyMetaObject <T> .GetBinderAdapter(binder), DynamicProxyMetaObject <T> .NoArgs, fallback(null), (DynamicMetaObject e) => binder.FallbackInvoke(e, args, null)), null));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var retval = innerMetaObject.BindInvokeMember(binder, args);
// call any parent object non-dynamic methods before trying wrapped object
var newretval = binder.FallbackInvokeMember(this, args, retval);
return(newretval);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (_runtime.TryInvokeMember == null)
{
return(base.BindInvokeMember(binder, args));
}
//
// Generate a tree like:
//
// {
// object result;
// TryInvokeMember(payload, out result)
// ? result
// : TryGetMember(payload, out result)
// ? FallbackInvoke(result)
// : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
DynamicMetaObject Fallback(DynamicMetaObject e) =>
binder.FallbackInvokeMember(this, args, e);
var call = BuildCallMethodWithResult(
"TryInvokeMember",
binder,
GetArgArray(args),
BuildCallMethodWithResult(
"TryGetMember",
new GetBinderAdapter(binder),
NoArgs,
Fallback(null),
e => binder.FallbackInvoke(e, args, null)
),
null
);
return(_dontFallbackFirst ? call : Fallback(call));
//
// See http://gist.github.com/386261 for why this is commented out
//
// IronRuby 1.0.0.0 on .NET 4.0.30319.1
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// >>> require 'Jayrock.Json'
// => true
// >>> o = Jayrock::Json::JsonObject.new
// => {}
// >>> o.foo = 123
// => 123
// >>> o.foo
// (ir):1: undefined method `foo' for {"foo":123}:Jayrock::Json::JsonObject (NoMethodError)
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
DynamicMetaObject messageSendMO;
if (createMetaObjectToSendMessage(binder.Name, argArrayFor(args), out messageSendMO))
{
return(messageSendMO);
}
return(binder.FallbackInvokeMember(this, args, messageSendMO));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
ContractUtils.RequiresNotNull(binder, "binder");
return(BindGetOrInvokeMember(
binder,
binder.Name,
binder.IgnoreCase,
binder.FallbackInvokeMember(this, args),
value => binder.FallbackInvoke(value, args, null)
));
}
public override DynamicMetaObject _0001(InvokeMemberBinder instance, DynamicMetaObject[] pol)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
if (!CancelProperty("TryInvokeMember"))
{
return(base.BindInvokeMember(instance, pol));
}
MessageComposer messageComposer = (DynamicMetaObject P_0) => instance.FallbackInvokeMember(this, pol, P_0);
return(CollectProperty("TryInvokeMember", instance, WorkerClientBridge <T> ._0001(pol), CollectProperty("TryGetMember", new ResolverPropertyStruct(instance), WorkerClientBridge <T> ._0001(), messageComposer(null), (DynamicMetaObject P_0) => instance.FallbackInvoke(P_0, pol, null)), null));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
// Generate a tree like:
//
// {
// object result;
// TryInvokeMember(payload, out result)
// ? result
// : TryGetMember(payload, out result)
// ? FallbackInvoke(result)
// : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
DynamicMetaObject call = BuildCallMethodWithResult(
DynamicObject_TryInvokeMember,
binder,
GetExpressions(args),
BuildCallMethodWithResult <GetMemberBinder> (
DynamicObject_TryGetMember,
new GetBinderAdapter(binder),
s_noArgs,
binder.FallbackInvokeMember(this, args, null),
(GreedyMetaDynamic @this, GetMemberBinder ignored, DynamicMetaObject e) => binder.FallbackInvoke(e, args, null)
),
null
);
// JJA - we should handle these methods, too, otherwise we can't wrap the result in another dynamic object.
if (binder.Name == "ToString" || binder.Name == "GetHashCode" || binder.Name == "GetType" || binder.Name == "Equals")
{
return(call);
}
return(binder.FallbackInvokeMember(this, args, call));
}
public override DynamicMetaObject/*!*/ BindInvokeMember(InvokeMemberBinder/*!*/ action, DynamicMetaObject/*!*/[]/*!*/ args) {
foreach (PythonType pt in Value.ResolutionOrder) {
PythonTypeSlot dummy;
if (pt.IsSystemType) {
return action.FallbackInvokeMember(this, args);
} else if (
pt.TryResolveSlot(DefaultContext.DefaultCLS, action.Name, out dummy) ||
pt.IsOldClass) {
break;
}
}
return BindingHelpers.GenericInvokeMember(action, null, this, args);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (!this.IsOverridden("TryInvokeMember"))
{
return(base.BindInvokeMember(binder, args));
}
Fallback <T> fallback = e => binder.FallbackInvokeMember((DynamicProxyMetaObject <T>) this, args, e);
DynamicMetaObject errorSuggestion = this.BuildCallMethodWithResult("TryInvokeMember", binder, DynamicProxyMetaObject <T> .GetArgArray(args), this.BuildCallMethodWithResult("TryGetMember", new GetBinderAdapter <T>(binder), DynamicProxyMetaObject <T> .NoArgs, fallback(null), e => binder.FallbackInvoke(e, args, null)), null);
if (!this._dontFallbackFirst)
{
return(fallback(errorSuggestion));
}
return(errorSuggestion);
}
// Token: 0x060015CA RID: 5578 RVA: 0x00067C5C File Offset: 0x00065E5C
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (!this.IsOverridden("TryInvokeMember"))
{
return(base.BindInvokeMember(binder, args));
}
Class_475 <T> .Fallback fallback = (DynamicMetaObject e) => binder.FallbackInvokeMember(this, args, e);
DynamicMetaObject dynamicMetaObject = this.BuildCallMethodWithResult("TryInvokeMember", binder, Class_475 <T> .GetArgArray(args), this.BuildCallMethodWithResult("TryGetMember", new Class_475 <T> .GetBinderAdapter(binder), Class_475 <T> .NoArgs, fallback(null), (DynamicMetaObject e) => binder.FallbackInvoke(e, args, null)), null);
if (!this._dontFallbackFirst)
{
return(fallback(dynamicMetaObject));
}
return(dynamicMetaObject);
}
/// <devdoc>
/// Because we don't ComboBind over several MOs and operations, and no one is falling back to
/// this function with MOs that have no values, we don't need to check HasValue. If we did
/// check, and HasValue == False, then would defer to new InvokeMemberBinder.Defer().
/// </devdoc>
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var members = ReflectedType.GetMember(binder.Name, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
if (members.Length == 1 && (members[0] is PropertyInfo || members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
var mem = members[0];
throw new NotImplementedException();
//return new DynamicMetaObject(
// Expression.Dynamic(
// new SymplInvokeBinder(new CallInfo(args.Length)),
// typeof(object),
// args.Select(a => a.Expression).AddFirst(
// Expression.MakeMemberAccess(this.Expression, mem)));
// Don't test for EventInfos since we do nothing with them now.
}
else
{
// Get MethodInfos with param types that work for args. This works for except for
// value args that need to pass to reftype params. We could detect that to be smarter
// and then explicitly StrongBox the args.
var res = Array.FindAll(members, member => member is MethodInfo m && m.GetParameters().Length == args.Length && RuntimeHelpers.ParametersMatchArguments(m.GetParameters(), args));
if (res.Length == 0)
{
// Sometimes when binding members on TypeModels the member is an instance member
// since the Type is an instance of Type. We fallback to the binder with the Type
// instance to see if it binds. The InvokeMemberBinder does handle this.
var typeMO = RuntimeHelpers.GetRuntimeTypeMoFromModel(this);
var result = binder.FallbackInvokeMember(typeMO, args, null);
return(result);
}
var meth = (MethodInfo)res[0];
// True below means generate an instance restriction on the MO. We are only looking
// at the members defined in this Type instance.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(this, args, true);
// restrictions and conversion must be done consistently.
var callArgs = RuntimeHelpers.ConvertArguments(args, meth.GetParameters());
return(new DynamicMetaObject(RuntimeHelpers.EnsureObjectResult(Expression.Call(meth, callArgs)), restrictions));
// Could hve tried just letting expression.Call factory do the work, but if there is more
// than one applicable method using just assignablefrom, expression.Call throws. It does
// not pick a "most applicable" method or any method.
}
}
} // func BindInvoke
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
if (String.Compare(binder.Name, nameof(IsSmall), binder.IgnoreCase) == 0 ||
String.Compare(binder.Name, nameof(IsLarge), binder.IgnoreCase) == 0)
{
return(base.BindInvokeMember(binder, args));
}
if (!HasValue)
{
return(binder.Defer(this, args));
}
// redirect to the item
return(binder.FallbackInvokeMember(GetRawItemBinder(), args));
} // func BindInvokeMember
public override DynamicMetaObject /*!*/ BindInvokeMember(InvokeMemberBinder /*!*/ action, DynamicMetaObject /*!*/[] /*!*/ args)
{
foreach (PythonType pt in Value.ResolutionOrder)
{
if (pt.IsSystemType)
{
return(action.FallbackInvokeMember(this, args));
}
else if (pt.TryResolveSlot(DefaultContext.DefaultCLS, action.Name, out _))
{
break;
}
}
return(BindingHelpers.GenericInvokeMember(action, null, this, args));
}
public override DynamicMetaObject BindInvokeMember(
InvokeMemberBinder binder,
DynamicMetaObject[] args
)
{
if (!IsOverridden(nameof(DynamicProxy <T> .TryInvokeMember)))
{
return(base.BindInvokeMember(binder, args));
}
//
// Generate a tree like:
//
// {
// object result;
// TryInvokeMember(payload, out result)
// ? result
// : TryGetMember(payload, out result)
// ? FallbackInvoke(result)
// : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
Fallback fallback = e => binder.FallbackInvokeMember(this, args, e);
return(BuildCallMethodWithResult(
nameof(DynamicProxy <T> .TryInvokeMember),
binder,
GetArgArray(args),
BuildCallMethodWithResult(
nameof(DynamicProxy <T> .TryGetMember),
new GetBinderAdapter(binder),
NoArgs,
fallback(null),
e => binder.FallbackInvoke(e, args, null)
),
null
));
}
public override DynamicMetaObject/*!*/ BindInvokeMember(InvokeMemberBinder/*!*/ action, DynamicMetaObject/*!*/[]/*!*/ args) {
ParameterExpression tmp = Expression.Parameter(typeof(object));
// first get the default binder value
DynamicMetaObject fallback = action.FallbackInvokeMember(this, args);
// then fallback w/ an error suggestion that does a late bound lookup.
return action.FallbackInvokeMember(
this,
args,
new DynamicMetaObject(
Ast.Block(
new[] { tmp },
Ast.Condition(
Ast.NotEqual(
Ast.Assign(
tmp,
Ast.Call(
typeof(PythonOps).GetMethod("PythonFunctionGetMember"),
AstUtils.Convert(
Expression,
typeof(PythonFunction)
),
Expression.Constant(action.Name)
)
),
Ast.Constant(OperationFailed.Value)
),
action.FallbackInvoke(
new DynamicMetaObject(tmp, BindingRestrictions.Empty),
args,
null
).Expression,
AstUtils.Convert(fallback.Expression, typeof(object))
)
),
BindingRestrictions.GetTypeRestriction(Expression, typeof(PythonFunction)).Merge(fallback.Restrictions)
)
);
}
// TODO: support for IgnoreCase in underlying ScriptScope APIs
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder action, DynamicMetaObject[] args)
{
var fallback = action.FallbackInvokeMember(this, args);
var result = Expression.Variable(typeof(object), "result");
var fallbackInvoke = action.FallbackInvoke(new DynamicMetaObject(result, BindingRestrictions.Empty), args, null);
return(new DynamicMetaObject(
Expression.Block(
new ParameterExpression[] { result },
Expression.Condition(
Expression.Call(
Expression.Convert(Expression, typeof(ScriptScope)),
typeof(ScriptScope).GetMethod("TryGetVariable", new[] { typeof(string), typeof(object).MakeByRefType() }),
Expression.Constant(action.Name),
result
),
Expression.Convert(fallbackInvoke.Expression, typeof(object)),
Expression.Convert(fallback.Expression, typeof(object))
)
),
BindingRestrictions.Combine(args).Merge(BindingRestrictions.GetTypeRestriction(Expression, typeof(ScriptScope))).Merge(fallback.Restrictions)
));
}
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
return(_originalBinder.FallbackInvokeMember(target, args, errorSuggestion));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {
return DynamicTryGetValue(binder.Name, binder.IgnoreCase,
binder.FallbackInvokeMember(this, args).Expression,
(tmp) => binder.FallbackInvoke(new DynamicMetaObject(tmp, BindingRestrictions.Empty), args, null).Expression
);
}
public override MetaObject BindInvokeMember(InvokeMemberBinder binder, MetaObject[] args)
{
ContractUtils.RequiresNotNull(binder, "binder");
return(binder.FallbackInvokeMember(UnwrapSelf(), args));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {
if (IsOverridden("TryInvokeMember")) {
return CallMethodWithResult("TryInvokeMember", binder, GetArgArray(args), (e) => binder.FallbackInvokeMember(this, args, e));
} else if (IsOverridden("TryGetMember")) {
// Generate a tree like:
//
// {
// object result;
// TryGetMember(payload, out result) ? FallbackInvoke(result) : fallbackResult
// }
//
// Then it calls FallbackInvokeMember with this tree as the
// "error", giving the language the option of using this
// tree or doing .NET binding.
//
return CallMethodWithResult(
"TryGetMember", new GetBinderAdapter(binder), NoArgs,
(e) => binder.FallbackInvokeMember(this, args, e),
(e) => binder.FallbackInvoke(e, args, null)
);
}
return base.BindInvokeMember(binder, args);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
return(binder.FallbackInvokeMember(UnwrapSelf(), args));
}
public override MetaObject /*!*/ BindInvokeMember(InvokeMemberBinder /*!*/ binder, params MetaObject /*!*/[] /*!*/ args)
{
var self = (IRubyObject)Value;
return(RubyInvokeMemberBinder.TryBind(self.Class.Context, binder, this, args) ?? binder.FallbackInvokeMember(this, args));
}
/// <summary>
/// Performs the binding of the dynamic invoke member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="InvokeMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke member operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackInvokeMember(this, args);
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
// Whether or not to try the parent object first...
return(binder.FallbackInvokeMember(this, args, innerMetaObject.BindInvokeMember(binder, args)));
//return innerMetaObject.BindInvokeMember(binder, args);
}
// Because we don't ComboBind over several MOs and operations, and no one
// is falling back to this function with MOs that have no values, we
// don't need to check HasValue. If we did check, and HasValue == False,
// then would defer to new InvokeMemberBinder.Defer().
//
public override DynamicMetaObject BindInvokeMember(
InvokeMemberBinder binder, DynamicMetaObject[] args)
{
var flags = BindingFlags.IgnoreCase | BindingFlags.Static |
BindingFlags.Public;
var members = ReflType.GetMember(binder.Name, flags);
if ((members.Length == 1) && (members[0] is PropertyInfo ||
members[0] is FieldInfo))
{
// NEED TO TEST, should check for delegate value too
var mem = members[0];
throw new NotImplementedException();
//return new DynamicMetaObject(
// Expression.Dynamic(
// new SymplInvokeBinder(new CallInfo(args.Length)),
// typeof(object),
// args.Select(a => a.Expression).AddFirst(
// Expression.MakeMemberAccess(this.Expression, mem)));
// Don't test for eventinfos since we do nothing with them now.
}
else
{
// Get MethodInfos with right arg counts.
var mi_mems = members.
Select(m => m as MethodInfo).
Where(m => m is MethodInfo &&
((MethodInfo)m).GetParameters().Length ==
args.Length);
// Get MethodInfos with param types that work for args. This works
// for except for value args that need to pass to reftype params.
// We could detect that to be smarter and then explicitly StrongBox
// the args.
List <MethodInfo> res = new List <MethodInfo>();
foreach (var mem in mi_mems)
{
if (RuntimeHelpers.ParametersMatchArguments(
mem.GetParameters(), args))
{
res.Add(mem);
}
}
if (res.Count == 0)
{
// Sometimes when binding members on TypeModels the member
// is an intance member since the Type is an instance of Type.
// We fallback to the binder with the Type instance to see if
// it binds. The SymplInvokeMemberBinder does handle this.
var typeMO = RuntimeHelpers.GetRuntimeTypeMoFromModel(this);
var result = binder.FallbackInvokeMember(typeMO, args, null);
return(result);
}
// True below means generate an instance restriction on the MO.
// We are only looking at the members defined in this Type instance.
var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
this, args, true);
// restrictions and conversion must be done consistently.
var callArgs =
RuntimeHelpers.ConvertArguments(
args, res[0].GetParameters());
return(new DynamicMetaObject(
RuntimeHelpers.EnsureObjectResult(
Expression.Call(res[0], callArgs)),
restrictions));
// Could hve tried just letting Expr.Call factory do the work,
// but if there is more than one applicable method using just
// assignablefrom, Expr.Call throws. It does not pick a "most
// applicable" method or any method.
}
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, nameof(binder));
return binder.FallbackInvokeMember(UnwrapSelf(), args);
}
/// <summary>
/// Performs the binding of the dynamic invoke member operation.
/// </summary>
/// <param name="binder">An instance of the <see cref="InvokeMemberBinder"/> that represents the details of the dynamic operation.</param>
/// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke member operation.</param>
/// <returns>The new <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
public virtual DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
{
ContractUtils.RequiresNotNull(binder, "binder");
return(binder.FallbackInvokeMember(this, args));
}
public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {
ContractUtils.RequiresNotNull(binder, "binder");
return binder.FallbackInvokeMember(UnwrapSelf(), args);
}