public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
IFastSettable fastSet = args[0] as IFastSettable;
if (fastSet != null)
{
T res = fastSet.MakeSetBinding <T>(site, this);
if (res != null)
{
return(res);
}
}
IPythonObject ipo = args[0] as IPythonObject;
if (ipo != null && !(ipo is IProxyObject))
{
FastBindResult <T> res = UserTypeOps.MakeSetBinding <T>(Context.SharedContext, site, ipo, args[1], this);
if (res.Target != null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.BindingFast, "IPythonObject");
if (res.ShouldCache)
{
CacheTarget(res.Target);
}
return(res.Target);
}
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "IPythonObject Set");
}
return(base.BindDelegate(site, args));
}
public override DynamicMetaObject /*!*/ BindDeleteMember(DeleteMemberBinder /*!*/ member)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Type DeleteMember " + Value.UnderlyingSystemType.FullName);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Type DeleteMember");
if (Value.IsSystemType)
{
PythonContext state = PythonContext.GetPythonContext(member);
MemberTracker tt = MemberTracker.FromMemberInfo(Value.UnderlyingSystemType);
// have the default binder perform it's operation against a TypeTracker and then
// replace the test w/ our own.
return(new DynamicMetaObject(
state.Binder.DeleteMember(
member.Name,
new DynamicMetaObject(
AstUtils.Constant(tt),
BindingRestrictions.Empty,
tt
),
state.SharedOverloadResolverFactory
).Expression,
BindingRestrictions.GetInstanceRestriction(Expression, Value).Merge(Restrictions)
));
}
return(MakeDeleteMember(member));
}
private DynamicMetaObject /*!*/ InvokeWorker(DynamicMetaObjectBinder /*!*/ call, DynamicMetaObject /*!*/[] /*!*/ args, Expression /*!*/ codeContext)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Type Invoke " + Value.UnderlyingSystemType.FullName + args.Length);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Type Invoke");
if (this.NeedsDeferral())
{
return(call.Defer(ArrayUtils.Insert(this, args)));
}
for (int i = 0; i < args.Length; i++)
{
if (args[i].NeedsDeferral())
{
return(call.Defer(ArrayUtils.Insert(this, args)));
}
}
DynamicMetaObject res;
if (IsStandardDotNetType(call))
{
res = MakeStandardDotNetTypeCall(call, codeContext, args);
}
else
{
res = MakePythonTypeCall(call, codeContext, args);
}
return(BindingHelpers.AddPythonBoxing(res));
}
public DelegateInfo(LanguageContext context, Type returnType, Type[] parameters)
{
Assert.NotNull(returnType);
Assert.NotNullItems(parameters);
_returnType = returnType;
_parameterTypes = parameters;
PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, ToString());
if (_returnType != typeof(void))
{
_convertBinder = context.CreateConvertBinder(_returnType, true);
}
_invokeBinder = context.CreateInvokeBinder(new CallInfo(_parameterTypes.Length));
Type[] delegateParams = new Type[1 + _parameterTypes.Length];
delegateParams[0] = typeof(object[]);
for (int i = 0; i < _parameterTypes.Length; i++)
{
delegateParams[1 + i] = _parameterTypes[i];
}
EmitClrCallStub(returnType, delegateParams, out _method);
}
public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
IFastInvokable ifi = args[1] as IFastInvokable;
if (ifi != null)
{
FastBindResult <T> res = ifi.MakeInvokeBinding(site, this, (CodeContext)args[0], ArrayUtils.ShiftLeft(args, 2));
if (res.Target != null)
{
if (res.ShouldCache)
{
base.CacheTarget(res.Target);
}
return(res.Target);
}
}
if (args[1] is Types.PythonType)
{
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "InvokeNoFast " + ((Types.PythonType)args[1]).Name);
}
else
{
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "InvokeNoFast " + CompilerHelpers.GetType(args[1]));
}
var target = this.LightBind <T>(args, Context.Options.CompilationThreshold);
base.CacheTarget(target);
return(target);
}
private DynamicMetaObject /*!*/ GetMemberWorker(DynamicMetaObjectBinder /*!*/ member, Expression codeContext)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Type GetMember " + Value.UnderlyingSystemType.FullName);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Type GetMember");
return(new MetaGetBinderHelper(this, member, codeContext, GetTypeTest(), MakeMetaTypeTest(Restrict(this.GetRuntimeType()).Expression)).MakeTypeGetMember());
}
private DynamicMetaObject /*!*/ InvokeWorker(DynamicMetaObjectBinder /*!*/ call, Expression /*!*/ codeContext, DynamicMetaObject /*!*/[] /*!*/ args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "BuiltinFunc Invoke " + Value.DeclaringType.FullName + "." + Value.Name + " with " + args.Length + " args " + Value.IsUnbound);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "BuiltinFunction " + Value.Targets.Count + ", " + Value.Targets[0].GetParameters().Length);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "BuiltinFunction " + BindingHelpers.GetCallSignature(call));
if (this.NeedsDeferral())
{
return(call.Defer(ArrayUtils.Insert(this, args)));
}
for (int i = 0; i < args.Length; i++)
{
if (args[i].NeedsDeferral())
{
return(call.Defer(ArrayUtils.Insert(this, args)));
}
}
if (Value.IsUnbound)
{
return(MakeSelflessCall(call, codeContext, args));
}
else
{
return(MakeSelfCall(call, codeContext, args));
}
}
internal override bool TryGetValue(CodeContext context, object instance, PythonType owner, out object value)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Properties, this);
value = CallGetter(context, owner, PythonContext.GetContext(context).GetGenericCallSiteStorage0(), instance);
return(true);
}
internal DelegateInfo(LanguageContext context, Type returnType, ParameterInfo[] parameters)
{
Assert.NotNull(returnType);
Assert.NotNullItems(parameters);
_returnType = returnType;
_parameters = parameters;
PerfTrack.NoteEvent(PerfTrack.Categories.DelegateCreate, ToString());
if (_returnType != typeof(void))
{
_convertBinder = context.CreateConvertBinder(_returnType, true);
}
_invokeBinder = context.CreateInvokeBinder(new CallInfo(_parameters.Length));
Type[] delegateParams = new Type[_parameters.Length];
for (int i = 0; i < _parameters.Length; i++)
{
delegateParams[i] = _parameters[i].ParameterType;
}
// Create the method with a special name so the langauge compiler knows that method's stack frame is not visible
DynamicILGen cg = Snippets.Shared.CreateDynamicMethod("_Scripting_", _returnType, ArrayUtils.Insert(typeof(object[]), delegateParams), false);
// Emit the stub
_constants = EmitClrCallStub(cg);
_method = cg.Finish();
}
private DynamicMetaObject BindConvert(DynamicMetaObject self)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Convert " + Type.FullName + " " + self.LimitType);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Conversion");
DynamicMetaObject res;
#if FEATURE_COM
DynamicMetaObject comConvert;
if (Microsoft.Scripting.ComInterop.ComBinder.TryConvert(CompatBinder, self, out comConvert))
{
res = comConvert;
}
else
#endif
{
res = self.BindConvert(CompatBinder);
}
// if we return object and the interop binder had to put on an extra conversion
// to the strong type go ahead and remove it now.
if (ReturnType == typeof(object) &&
res.Expression.Type != typeof(object) &&
res.Expression.NodeType == ExpressionType.Convert)
{
res = new DynamicMetaObject(
((UnaryExpression)res.Expression).Operand,
res.Restrictions
);
}
return(res);
}
private void Compile(object frameObj)
{
if (Compiled)
{
return;
}
lock (this) {
if (Compiled)
{
return;
}
PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Interpreted loop compiled");
InterpretedFrame frame = (InterpretedFrame)frameObj;
var compiler = new LoopCompiler(_loop, frame.Interpreter.LabelMapping, _variables, _closureVariables, _instructionIndex, _loopEnd);
var instructions = frame.Interpreter.Instructions.Instructions;
// replace this instruction with an optimized one:
Interlocked.Exchange(ref instructions[_instructionIndex], new CompiledLoopInstruction(compiler.CreateDelegate()));
// invalidate this instruction, some threads may still hold on it:
_loop = null;
_variables = null;
_closureVariables = null;
}
}
protected Node(SourceSpan location)
{
_location = location;
#if DEBUG
PerfTrack.NoteEvent(PerfTrack.Categories.Count, "RubyAST: " + GetType().Name);
#endif
}
public static PythonType /*!*/ GetPythonTypeFromType(Type /*!*/ type)
{
ContractUtils.RequiresNotNull(type, "type");
PerfTrack.NoteEvent(PerfTrack.Categories.DictInvoke, "TypeLookup " + type.FullName);
return(PythonType.GetPythonType(type));
}
private DynamicMetaObject /*!*/ MakeCallRule(DynamicMetaObjectBinder /*!*/ call, Expression /*!*/ codeContext, DynamicMetaObject[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass Invoke w/ " + args.Length + " args");
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "OldClass Invoke");
CallSignature signature = BindingHelpers.GetCallSignature(call);
// TODO: If we know __init__ wasn't present we could construct the OldInstance directly.
Expression[] exprArgs = new Expression[args.Length];
for (int i = 0; i < args.Length; i++)
{
exprArgs[i] = args[i].Expression;
}
ParameterExpression init = Ast.Variable(typeof(object), "init");
ParameterExpression instTmp = Ast.Variable(typeof(object), "inst");
DynamicMetaObject self = Restrict(typeof(OldClass));
return(new DynamicMetaObject(
Ast.Block(
new ParameterExpression[] { init, instTmp },
Ast.Assign(
instTmp,
Ast.New(
typeof(OldInstance).GetConstructor(new Type[] { typeof(CodeContext), typeof(OldClass) }),
codeContext,
self.Expression
)
),
Ast.Condition(
Expression.Not(
Expression.TypeIs(
Expression.Assign(
init,
Ast.Call(
typeof(PythonOps).GetMethod("OldClassTryLookupInit"),
self.Expression,
instTmp
)
),
typeof(OperationFailed)
)
),
Ast.Dynamic(
PythonContext.GetPythonContext(call).Invoke(
signature
),
typeof(object),
ArrayUtils.Insert <Expression>(codeContext, init, exprArgs)
),
NoInitCheckNoArgs(signature, self, args)
),
instTmp
),
self.Restrictions.Merge(BindingRestrictions.Combine(args))
));
}
private DynamicMetaObject InvokeWorker(DynamicMetaObjectBinder /*!*/ callAction, DynamicMetaObject /*!*/[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Method Invoke " + args.Length);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Method");
CallSignature signature = BindingHelpers.GetCallSignature(callAction);
DynamicMetaObject self = Restrict(typeof(Method));
BindingRestrictions restrictions = self.Restrictions;
// restrict to non-null self (Method is immutable so this is an invariant test)
restrictions = restrictions.Merge(
BindingRestrictions.GetExpressionRestriction(
Ast.NotEqual(
GetSelfExpression(self),
AstUtils.Constant(null)
)
)
);
DynamicMetaObject[] newArgs = ArrayUtils.Insert(GetMetaFunction(self), GetMetaSelf(self), args);
var newSig = new CallSignature(ArrayUtils.Insert(new Argument(ArgumentType.Simple), signature.GetArgumentInfos()));
var call = new DynamicMetaObject(
DynamicExpression.Dynamic(
PythonContext.GetPythonContext(callAction).Invoke(
newSig
).GetLightExceptionBinder(callAction.SupportsLightThrow()),
typeof(object),
ArrayUtils.Insert(PythonContext.GetCodeContext(callAction), DynamicUtils.GetExpressions(newArgs))
),
BindingRestrictions.Empty
);
/*
* call = func.Invoke(
* new CallBinder(
* PythonContext.GetBinderState(callAction),
* newSig
* ),
* newArgs
* );*/
if (call.HasValue)
{
return(new DynamicMetaObject(
call.Expression,
restrictions.Merge(call.Restrictions),
call.Value
));
}
else
{
return(new DynamicMetaObject(
call.Expression,
restrictions.Merge(call.Restrictions)
));
}
}
private DynamicMetaObject /*!*/ InvokeWorker(DynamicMetaObjectBinder /*!*/ invoke, Expression /*!*/ codeContext, DynamicMetaObject /*!*/[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass Invoke");
DynamicMetaObject self = Restrict(typeof(OldInstance));
Expression[] exprArgs = new Expression[args.Length + 1];
for (int i = 0; i < args.Length; i++)
{
exprArgs[i + 1] = args[i].Expression;
}
ParameterExpression tmp = Ast.Variable(typeof(object), "callFunc");
exprArgs[0] = tmp;
return(new DynamicMetaObject(
// we could get better throughput w/ a more specific rule against our current custom old class but
// this favors less code generation.
Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
Ast.Call(
typeof(PythonOps).GetMethod("OldInstanceTryGetBoundCustomMember"),
codeContext,
self.Expression,
AstUtils.Constant("__call__"),
tmp
),
Ast.Block(
Utils.Try(
Ast.Call(typeof(PythonOps).GetMethod("FunctionPushFrameCodeContext"), codeContext),
Ast.Assign(
tmp,
Ast.Dynamic(
PythonContext.GetPythonContext(invoke).Invoke(
BindingHelpers.GetCallSignature(invoke)
),
typeof(object),
ArrayUtils.Insert(codeContext, exprArgs)
)
)
).Finally(
Ast.Call(typeof(PythonOps).GetMethod("FunctionPopFrame"))
),
tmp
),
Utils.Convert(
BindingHelpers.InvokeFallback(invoke, codeContext, this, args).Expression,
typeof(object)
)
)
),
self.Restrictions.Merge(BindingRestrictions.Combine(args))
));
}
DynamicMetaObject IPythonOperable.BindOperation(PythonOperationBinder action, DynamicMetaObject[] args) {
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "BuiltinFunc Operation " + action.Operation);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "BuiltinFunc Operation");
switch (action.Operation) {
case PythonOperationKind.CallSignatures:
return PythonProtocol.MakeCallSignatureOperation(this, Value.Targets);
}
return null;
}
public DynamicMetaObject ConvertWorker(DynamicMetaObjectBinder binder, Type toType, ConversionResultKind kind)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass Convert");
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "OldClass Convert");
if (toType.IsSubclassOf(typeof(Delegate)))
{
return(MakeDelegateTarget(binder, toType, Restrict(typeof(OldClass))));
}
return(FallbackConvert(binder));
}
/// <summary>
/// Creates the LambdaExpression which is the actual function body.
/// </summary>
private LightLambdaExpression EnsureFunctionLambda()
{
if (_dlrBody == null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody");
_dlrBody = CreateFunctionLambda();
}
return(_dlrBody);
}
internal override LightLambdaExpression GetLambda()
{
if (_dlrBody == null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody");
_dlrBody = MakeClassBody();
}
return(_dlrBody);
}
DynamicMetaObject IPythonOperable.BindOperation(PythonOperationBinder action, DynamicMetaObject[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass PythonOperation " + action.Operation);
if (action.Operation == PythonOperationKind.IsCallable)
{
return(MakeIsCallable(action));
}
return(null);
}
internal static bool TryInvokeTernaryOperator(CodeContext context, object o, object arg1, object arg2, string name, out object value)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Temporary, "TernaryOp " + CompilerHelpers.GetType(o).Name + " " + name);
if (TryGetOperator(context, o, name, out object callable))
{
value = PythonCalls.Call(context, callable, arg1, arg2);
return(true);
}
value = null;
return(false);
}
private void DoSet(CodeContext context, object instance, object val, bool suppressWarning)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Fields, this);
if (_info.IsInitOnly || _info.IsLiteral)
{
throw PythonOps.AttributeErrorForReadonlyAttribute(_info.DeclaringType.Name, _info.Name);
}
else if (!suppressWarning && instance != null && instance.GetType().IsValueType)
{
PythonOps.Warn(context, PythonExceptions.RuntimeWarning, UpdateValueTypeFieldWarning, _info.Name, _info.DeclaringType.Name);
}
_info.SetValue(instance, context.LanguageContext.Binder.Convert(val, _info.FieldType));
}
internal static DynamicMetaObject FallbackWorker(PythonContext context, DynamicMetaObject /*!*/ self, DynamicMetaObject /*!*/ codeContext, string name, GetMemberOptions options, DynamicMetaObjectBinder action, DynamicMetaObject errorSuggestion)
{
if (self.NeedsDeferral())
{
return(action.Defer(self));
}
PythonOverloadResolverFactory resolverFactory = new PythonOverloadResolverFactory(context.Binder, codeContext.Expression);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "FallbackGet");
bool isNoThrow = ((options & GetMemberOptions.IsNoThrow) != 0) ? true : false;
Type limitType = self.GetLimitType();
if (limitType == typeof(DynamicNull) || PythonBinder.IsPythonType(limitType))
{
// look up in the PythonType so that we can
// get our custom method names (e.g. string.startswith)
PythonType argType = DynamicHelpers.GetPythonTypeFromType(limitType);
// if the name is defined in the CLS context but not the normal context then
// we will hide it.
if (argType.IsHiddenMember(name))
{
DynamicMetaObject baseRes = PythonContext.GetPythonContext(action).Binder.GetMember(
name,
self,
resolverFactory,
isNoThrow,
errorSuggestion
);
Expression failure = GetFailureExpression(limitType, self, name, isNoThrow, action);
return(BindingHelpers.FilterShowCls(codeContext, action, baseRes, failure));
}
}
var res = PythonContext.GetPythonContext(action).Binder.GetMember(name, self, resolverFactory, isNoThrow, errorSuggestion);
// Default binder can return something typed to boolean or int.
// If that happens, we need to apply Python's boxing rules.
if (res.Expression.Type.IsValueType)
{
res = new DynamicMetaObject(
AstUtils.Convert(res.Expression, typeof(object)),
res.Restrictions
);
}
return(res);
}
public DynamicMetaObject ConvertWorker(DynamicMetaObjectBinder binder, Type type, Type retType, ConversionResultKind kind)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Conversion " + type.FullName);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Conversion");
ValidationInfo typeTest = BindingHelpers.GetValidationInfo(this, Value.PythonType);
return(BindingHelpers.AddDynamicTestAndDefer(
binder,
TryPythonConversion(binder, type) ?? FallbackConvert(binder),
new DynamicMetaObject[] { this },
typeTest,
retType
));
}
internal override bool TryGetValue(CodeContext context, object instance, PythonType owner, out object value)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Fields, this);
if (instance == null)
{
value = _info.IsStatic ? _info.GetValue(null) : this;
}
else
{
value = _info.GetValue(context.LanguageContext.Binder.Convert(instance, _info.DeclaringType));
}
return(true);
}
private DynamicMetaObject /*!*/ MakeSetMember(string /*!*/ name, DynamicMetaObject /*!*/ value)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass SetMember");
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "OldClass SetMember");
DynamicMetaObject self = Restrict(typeof(OldClass));
Expression call, valueExpr = AstUtils.Convert(value.Expression, typeof(object));
switch (name)
{
case "__bases__":
call = Ast.Call(
typeof(PythonOps).GetMethod("OldClassSetBases"),
self.Expression,
valueExpr
);
break;
case "__name__":
call = Ast.Call(
typeof(PythonOps).GetMethod("OldClassSetName"),
self.Expression,
valueExpr
);
break;
case "__dict__":
call = Ast.Call(
typeof(PythonOps).GetMethod("OldClassSetDictionary"),
self.Expression,
valueExpr
);
break;
default:
call = Ast.Call(
typeof(PythonOps).GetMethod("OldClassSetNameHelper"),
self.Expression,
AstUtils.Constant(name),
valueExpr
);
break;
}
return(new DynamicMetaObject(
call,
self.Restrictions.Merge(value.Restrictions)
));
}
protected override T MakeTarget(CodeContext context)
{
if (_rules.Count == 1 && this != _rules[0].MonomorphicRuleSet)
{
// use the monomorphic rule if we only have 1 rule.
return(_rules[0].MonomorphicRuleSet.GetOrMakeTarget(context));
}
PerfTrack.NoteEvent(PerfTrack.Categories.Rules, "GenerateRule");
MethodInfo mi = typeof(T).GetMethod("Invoke");
CodeGen cg = ScriptDomainManager.CurrentManager.Snippets.Assembly.DefineMethod(
StubName,
mi.ReturnType,
ReflectionUtils.GetParameterTypes(mi.GetParameters()),
new ConstantPool()
);
cg.EmitLineInfo = false;
cg.Binder = context.LanguageContext.Binder;
if (DynamicSiteHelpers.IsFastTarget(typeof(T)))
{
cg.ContextSlot = new PropertySlot(cg.ArgumentSlots[0], typeof(FastDynamicSite).GetProperty("Context"));
}
else
{
cg.ContextSlot = cg.ArgumentSlots[1];
}
foreach (StandardRule <T> rule in _rules)
{
Label nextTest = cg.DefineLabel();
rule.Emit(cg, nextTest);
cg.MarkLabel(nextTest);
}
EmitNoMatch(cg);
if (_rules.Count == 1 &&
this == _rules[0].MonomorphicRuleSet &&
_rules[0].TemplateParameterCount > 0 &&
cg.IsDynamicMethod)
{
_monomorphicTemplate = (DynamicMethod)cg.MethodInfo;
}
return((T)(object)cg.CreateDelegate(typeof(T)));
}
private DynamicMetaObject /*!*/ InvokeWorker(DynamicMetaObjectBinder /*!*/ call, Expression /*!*/ codeContext, DynamicMetaObject /*!*/[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "BuiltinMethodDesc Invoke " + Value.DeclaringType + "." + Value.__name__ + " w/ " + args.Length + " args");
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "BuiltinMethodDesc Invoke");
CallSignature signature = BindingHelpers.GetCallSignature(call);
BindingRestrictions selfRestrict = BindingRestrictions.GetInstanceRestriction(Expression, Value).Merge(Restrictions);
selfRestrict = selfRestrict.Merge(
BindingRestrictions.GetExpressionRestriction(
MakeFunctionTest(
Ast.Call(
typeof(PythonOps).GetMethod("GetBuiltinMethodDescriptorTemplate"),
Ast.Convert(Expression, typeof(BuiltinMethodDescriptor))
)
)
)
);
return(Value.Template.MakeBuiltinFunctionCall(
call,
codeContext,
this,
args,
false, // no self
selfRestrict,
(newArgs) => {
BindingTarget target;
PythonContext state = PythonContext.GetPythonContext(call);
DynamicMetaObject res = state.Binder.CallMethod(
new PythonOverloadResolver(
state.Binder,
newArgs,
signature,
codeContext
),
Value.Template.Targets,
selfRestrict,
Value.Template.Name,
NarrowingLevel.None,
Value.Template.IsBinaryOperator ? PythonNarrowing.BinaryOperator : NarrowingLevel.All,
out target
);
return BindingHelpers.CheckLightThrow(call, res, target);
}));
}
private DynamicMetaObject /*!*/ MakeDeleteMember(DeleteMemberBinder /*!*/ member)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "OldClass DeleteMember");
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "OldClass DeleteMember");
DynamicMetaObject self = Restrict(typeof(OldClass));
return(new DynamicMetaObject(
Ast.Call(
typeof(PythonOps).GetMethod("OldClassDeleteMember"),
AstUtils.Constant(PythonContext.GetPythonContext(member).SharedContext),
self.Expression,
AstUtils.Constant(member.Name)
),
self.Restrictions
));
}