public DynamicMetaObject Create(CallSignature signature, ParameterBinderWithCodeContext parameterBinder, DynamicMetaObject target, DynamicMetaObject[] args) {
Type t = GetTargetType(target.Value);
if (t != null) {
if (typeof(Delegate).IsAssignableFrom(t) && args.Length == 1) {
MethodInfo dc = GetDelegateCtor(t);
// BinderOps.CreateDelegate<T>(CodeContext context, object callable);
return new DynamicMetaObject(
Ast.Call(null, dc, parameterBinder.ContextExpression, args[0].Expression),
target.Restrictions.Merge(BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value))
);
}
return CallMethod(parameterBinder, CompilerHelpers.GetConstructors(t, PrivateBinding), args, signature);
}
return null;
}
private DynamicMetaObject/*!*/ MakeSelfCall(DynamicMetaObjectBinder/*!*/ call, Expression/*!*/ codeContext, DynamicMetaObject/*!*/[]/*!*/ args) {
BindingRestrictions selfRestrict = Restrictions.Merge(
BindingRestrictionsHelpers.GetRuntimeTypeRestriction(
Expression,
typeof(BuiltinFunction)
)
).Merge(
BindingRestrictions.GetExpressionRestriction(
Value.MakeBoundFunctionTest(
AstUtils.Convert(Expression, typeof(BuiltinFunction))
)
)
);
Expression instance = Ast.Property(
AstUtils.Convert(
Expression,
typeof(BuiltinFunction)
),
typeof(BuiltinFunction).GetProperty("__self__")
);
DynamicMetaObject self = GetInstance(instance, CompilerHelpers.GetType(Value.__self__));
return Value.MakeBuiltinFunctionCall(
call,
codeContext,
this,
ArrayUtils.Insert(self, args),
true, // has self
selfRestrict,
(newArgs) => {
CallSignature signature = BindingHelpers.GetCallSignature(call);
DynamicMetaObject res;
BinderState state = BinderState.GetBinderState(call);
BindingTarget target;
var mc = new ParameterBinderWithCodeContext(state.Binder, codeContext);
if (Value.IsReversedOperator) {
res = state.Binder.CallMethod(
mc,
Value.Targets,
newArgs,
GetReversedSignature(signature),
self.Restrictions,
NarrowingLevel.None,
Value.IsBinaryOperator ?
PythonNarrowing.BinaryOperator :
NarrowingLevel.All,
Value.Name,
out target
);
} else {
res = state.Binder.CallInstanceMethod(
mc,
Value.Targets,
self,
args,
signature,
self.Restrictions,
NarrowingLevel.None,
Value.IsBinaryOperator ?
PythonNarrowing.BinaryOperator :
NarrowingLevel.All,
Value.Name,
out target
);
}
return new BuiltinFunction.BindingResult(target, res);
}
);
}
public override DynamicMetaObject/*!*/ GetExpression(DefaultBinder/*!*/ binder) {
var mc = new ParameterBinderWithCodeContext(binder, CodeContext);
CallSignature sig = Arguments.Signature.InsertArgument(new Argument(ArgumentType.Simple));
return binder.CallMethod(
mc,
_ctor.Targets,
ArrayUtils.Insert(Arguments.Self, Arguments.Arguments),
sig,
_creating.Name
);
}
public override DynamicMetaObject/*!*/ GetExpression(DefaultBinder/*!*/ binder) {
var mc = new ParameterBinderWithCodeContext(binder, CodeContext);
if (_creating.IsSystemType) {
return binder.CallMethod(
mc,
_creating.UnderlyingSystemType.GetConstructors(),
Arguments.Arguments,
Arguments.Signature,
Arguments.Self.Restrictions,
_creating.Name
);
}
return binder.CallMethod(
mc,
_creating.UnderlyingSystemType.GetConstructors(),
ArrayUtils.Insert(Arguments.Self, Arguments.Arguments),
GetDynamicNewSignature(),
Arguments.Self.Restrictions,
_creating.Name
);
}
public override DynamicMetaObject/*!*/ GetExpression(DefaultBinder/*!*/ binder) {
var mc = new ParameterBinderWithCodeContext(binder, CodeContext);
if (_creating.IsSystemType) {
return binder.CallMethod(
mc,
_creating.UnderlyingSystemType.GetConstructors(),
new DynamicMetaObject[0],
new CallSignature(0),
BindingRestrictions.Empty,
_creating.Name
);
}
return binder.CallMethod(
mc,
_creating.UnderlyingSystemType.GetConstructors(),
new DynamicMetaObject[] { Arguments.Self },
new CallSignature(1),
BindingRestrictions.Empty,
_creating.Name
);
}
internal DynamicMetaObject/*!*/ InvokeFallback(DynamicMetaObject/*!*/ target, DynamicMetaObject/*!*/[]/*!*/ args, CallSignature sig) {
var parameterBinder = new ParameterBinderWithCodeContext(Binder.Binder, Expression.Constant(_state.Context));
return PythonProtocol.Call(this, target, args) ??
Binder.Binder.Create(sig, parameterBinder, target, args) ??
Binder.Binder.Call(sig, parameterBinder, target, args);
}
/// <summary>
/// Trys to geta MethodBinder associated the slot for the specified type.
///
/// If a method is found the binder is set and true is returned.
/// If nothing is found binder is null and true is returned.
/// If something other than a method is found false is returned.
///
/// TODO: Remove rop
/// </summary>
internal static bool TryGetBinder(BinderState/*!*/ state, DynamicMetaObject/*!*/[]/*!*/ types, SymbolId op, SymbolId rop, out SlotOrFunction/*!*/ res, out PythonType declaringType) {
declaringType = null;
DynamicMetaObject xType = types[0];
BuiltinFunction xBf;
if (!BindingHelpers.TryGetStaticFunction(state, op, xType, out xBf)) {
res = SlotOrFunction.Empty;
return false;
}
xBf = CheckAlwaysNotImplemented(xBf);
BindingTarget bt;
DynamicMetaObject binder;
DynamicMetaObject yType = null;
BuiltinFunction yBf = null;
if (types.Length > 1) {
yType = types[1];
if (!BindingHelpers.IsSubclassOf(xType, yType) && !BindingHelpers.TryGetStaticFunction(state, rop, yType, out yBf)) {
res = SlotOrFunction.Empty;
return false;
}
yBf = CheckAlwaysNotImplemented(yBf);
}
if (yBf == xBf) {
yBf = null;
} else if (yBf != null && BindingHelpers.IsSubclassOf(yType, xType)) {
xBf = null;
}
var mc = new ParameterBinderWithCodeContext(state.Binder, AstUtils.Constant(state.Context));
if (xBf == null) {
if (yBf == null) {
binder = null;
bt = null;
} else {
declaringType = DynamicHelpers.GetPythonTypeFromType(yBf.DeclaringType);
binder = state.Binder.CallMethod(
mc,
yBf.Targets,
types,
new CallSignature(types.Length),
BindingRestrictions.Empty,
PythonNarrowing.None,
PythonNarrowing.BinaryOperator,
out bt
);
}
} else {
if (yBf == null) {
declaringType = DynamicHelpers.GetPythonTypeFromType(xBf.DeclaringType);
binder = state.Binder.CallMethod(
mc,
xBf.Targets,
types,
new CallSignature(types.Length),
BindingRestrictions.Empty,
PythonNarrowing.None,
PythonNarrowing.BinaryOperator,
out bt
);
} else {
List<MethodBase> targets = new List<MethodBase>();
targets.AddRange(xBf.Targets);
foreach (MethodBase mb in yBf.Targets) {
if (!ContainsMethodSignature(targets, mb)) targets.Add(mb);
}
binder = state.Binder.CallMethod(
mc,
targets.ToArray(),
types,
new CallSignature(types.Length),
BindingRestrictions.Empty,
PythonNarrowing.None,
PythonNarrowing.BinaryOperator,
out bt
);
foreach (MethodBase mb in yBf.Targets) {
if (bt.Method == mb) {
declaringType = DynamicHelpers.GetPythonTypeFromType(yBf.DeclaringType);
break;
}
}
if (declaringType == null) {
declaringType = DynamicHelpers.GetPythonTypeFromType(xBf.DeclaringType);
}
}
}
if (binder != null) {
res = new SlotOrFunction(bt, binder);
} else {
res = SlotOrFunction.Empty;
}
Debug.Assert(res != null);
return true;
}
