public DynamicMetaObject Create(CallSignature signature, DynamicMetaObject target, DynamicMetaObject[] args, Expression contextExpression)
{
Type t = GetTargetType(target.Value);
if (t != null)
{
if (typeof(Delegate).IsAssignableFrom(t) && args.Length == 1)
{
// PythonOps.GetDelegate(CodeContext context, object callable, Type t);
return(new DynamicMetaObject(
Ast.Call(
typeof(PythonOps).GetMethod("GetDelegate"),
contextExpression,
AstUtils.Convert(args[0].Expression, typeof(object)),
Expression.Constant(t)
),
target.Restrictions.Merge(BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value))
));
}
return(CallMethod(
new PythonOverloadResolver(
this,
args,
signature,
contextExpression
),
CompilerHelpers.GetConstructors(t, PrivateBinding),
target.Restrictions.Merge(BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value))
));
}
return(null);
}
private static BuiltinFunction GetConstructor(Type t, bool privateBinding)
{
BuiltinFunction ctorFunc = InstanceOps.NonDefaultNewInst;
MethodBase[] ctors = CompilerHelpers.GetConstructors(t, privateBinding, true);
return(GetConstructor(t, ctorFunc, ctors));
}
internal static MethodBase[] GetConstructors(Type t, bool privateBinding, bool includeProtected = false)
{
MethodBase[] ctors = CompilerHelpers.GetConstructors(t, privateBinding, includeProtected);
if (t.IsEnum())
{
var enumCtor = typeof(PythonTypeOps).GetDeclaredMethods(nameof(CreateEnum)).Single().MakeGenericMethod(t);
ctors = ctors.Concat(new[] { enumCtor }).ToArray();
}
return(ctors);
}
protected override MethodBase[] GetTargetMethods()
{
object target = Arguments[0];
Type t = GetTargetType(target);
if (t != null)
{
Test = Ast.AndAlso(Test, Ast.Equal(Rule.Parameters[0], Ast.Constant(target)));
return(CompilerHelpers.GetConstructors(t, Binder.PrivateBinding));
}
return(null);
}
/// <summary>
/// Creating a standard .NET type is easy - we just call it's constructor with the provided
/// arguments.
/// </summary>
private DynamicMetaObject /*!*/ MakeStandardDotNetTypeCall(DynamicMetaObjectBinder /*!*/ call, Expression /*!*/ codeContext, DynamicMetaObject /*!*/[] /*!*/ args)
{
CallSignature signature = BindingHelpers.GetCallSignature(call);
PythonContext state = PythonContext.GetPythonContext(call);
MethodBase[] ctors = CompilerHelpers.GetConstructors(Value.UnderlyingSystemType, state.Binder.PrivateBinding);
if (ctors.Length > 0)
{
return(state.Binder.CallMethod(
new PythonOverloadResolver(
state.Binder,
args,
signature,
codeContext
),
ctors,
Restrictions.Merge(BindingRestrictions.GetInstanceRestriction(Expression, Value))
));
}
else
{
string msg;
if (Value.UnderlyingSystemType.IsAbstract)
{
msg = String.Format("Cannot create instances of {0} because it is abstract", Value.Name);
}
else
{
msg = String.Format("Cannot create instances of {0} because it has no public constructors", Value.Name);
}
return(new DynamicMetaObject(
call.Throw(
Ast.New(
typeof(TypeErrorException).GetConstructor(new Type[] { typeof(string) }),
AstUtils.Constant(msg)
)
),
Restrictions.Merge(BindingRestrictions.GetInstanceRestriction(Expression, Value))
));
}
}
public MetaObject Create(CallSignature signature, ParameterBinderWithCodeContext parameterBinder, MetaObject target, MetaObject[] 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 MetaObject(
Ast.Call(null, dc, parameterBinder.ContextExpression, args[0].Expression),
target.Restrictions.Merge(Restrictions.GetInstanceRestriction(target.Expression, target.Value))
));
}
return(CallMethod(parameterBinder, CompilerHelpers.GetConstructors(t, PrivateBinding), args, signature));
}
return(null);
}