private DynamicMetaObject /*!*/ MakeToBoolConversion(DynamicMetaObject /*!*/ self)
{
DynamicMetaObject res;
if (self.HasValue)
{
self = self.Restrict(self.GetRuntimeType());
}
// Optimization: if we already boxed it to a bool, and now
// we're unboxing it, remove the unnecessary box.
if (self.Expression.NodeType == ExpressionType.Convert && self.Expression.Type == typeof(object))
{
var convert = (UnaryExpression)self.Expression;
if (convert.Operand.Type == typeof(bool))
{
return(new DynamicMetaObject(convert.Operand, self.Restrictions));
}
}
if (self.GetLimitType() == typeof(DynamicNull))
{
// None has no __nonzero__ and no __len__ but it's always false
res = MakeNoneToBoolConversion(self);
}
else if (self.GetLimitType() == typeof(bool))
{
// nothing special to convert from bool to bool
res = self;
}
else if (typeof(IStrongBox).IsAssignableFrom(self.GetLimitType()))
{
// Explictly block conversion of References to bool
res = MakeStrongBoxToBoolConversionError(self);
}
else if (self.GetLimitType().IsPrimitive || self.GetLimitType().IsEnum)
{
// optimization - rather than doing a method call for primitives and enums generate
// the comparison to zero directly.
res = MakePrimitiveToBoolComparison(self);
}
else
{
// anything non-null that doesn't fall under one of the above rules is true. So we
// fallback to the base Python conversion which will check for __nonzero__ and
// __len__. The fallback is handled by our ConvertTo site binder.
return
(PythonProtocol.ConvertToBool(this, self) ??
new DynamicMetaObject(
AstUtils.Constant(true),
self.Restrictions
));
}
return(res);
}
private DynamicMetaObject /*!*/ MakeConvertRuleForCall(DynamicMetaObjectBinder /*!*/ convertToAction, Type toType, DynamicMetaObject /*!*/ self, string name, string returner, Func <DynamicMetaObject> fallback, Func <Expression, Expression> resultConverter)
{
PythonType pt = ((IPythonObject)self.Value).PythonType;
PythonTypeSlot pts;
CodeContext context = PythonContext.GetPythonContext(convertToAction).SharedContext;
ValidationInfo valInfo = BindingHelpers.GetValidationInfo(this, pt);
if (pt.TryResolveSlot(context, name, out pts) && !IsBuiltinConversion(context, pts, name, pt))
{
ParameterExpression tmp = Ast.Variable(typeof(object), "func");
Expression callExpr = resultConverter(
Ast.Call(
PythonOps.GetConversionHelper(returner, GetResultKind(convertToAction)),
Ast.Dynamic(
PythonContext.GetPythonContext(convertToAction).InvokeNone,
typeof(object),
PythonContext.GetCodeContext(convertToAction),
tmp
)
)
);
if (typeof(Extensible <>).MakeGenericType(toType).IsAssignableFrom(self.GetLimitType()))
{
// if we're doing a conversion to the underlying type and we're an
// Extensible<T> of that type:
// if an extensible type returns it's self in a conversion, then we need
// to actually return the underlying value. If an extensible just keeps
// returning more instances of it's self a stack overflow occurs - both
// behaviors match CPython.
callExpr = AstUtils.Convert(AddExtensibleSelfCheck(convertToAction, toType, self, callExpr), typeof(object));
}
return(BindingHelpers.AddDynamicTestAndDefer(
convertToAction,
new DynamicMetaObject(
Ast.Condition(
MakeTryGetTypeMember(
PythonContext.GetPythonContext(convertToAction),
pts,
self.Expression,
tmp
),
callExpr,
AstUtils.Convert(
ConversionFallback(convertToAction),
typeof(object)
)
),
self.Restrict(self.GetRuntimeType()).Restrictions
),
new DynamicMetaObject[] { this },
valInfo,
tmp
));
}
return(fallback());
}
private DynamicMetaObject/*!*/ MakeConvertRuleForCall(DynamicMetaObjectBinder/*!*/ convertToAction, Type toType, DynamicMetaObject/*!*/ self, string name, string returner, Func<DynamicMetaObject> fallback, Func<Expression, Expression> resultConverter) {
PythonType pt = ((IPythonObject)self.Value).PythonType;
PythonTypeSlot pts;
CodeContext context = PythonContext.GetPythonContext(convertToAction).SharedContext;
ValidationInfo valInfo = BindingHelpers.GetValidationInfo(this, pt);
if (pt.TryResolveSlot(context, name, out pts) && !IsBuiltinConversion(context, pts, name, pt)) {
ParameterExpression tmp = Ast.Variable(typeof(object), "func");
Expression callExpr = resultConverter(
Ast.Call(
PythonOps.GetConversionHelper(returner, GetResultKind(convertToAction)),
Ast.Dynamic(
PythonContext.GetPythonContext(convertToAction).InvokeNone,
typeof(object),
PythonContext.GetCodeContext(convertToAction),
tmp
)
)
);
if (typeof(Extensible<>).MakeGenericType(toType).IsAssignableFrom(self.GetLimitType())) {
// if we're doing a conversion to the underlying type and we're an
// Extensible<T> of that type:
// if an extensible type returns it's self in a conversion, then we need
// to actually return the underlying value. If an extensible just keeps
// returning more instances of it's self a stack overflow occurs - both
// behaviors match CPython.
callExpr = AstUtils.Convert(AddExtensibleSelfCheck(convertToAction, toType, self, callExpr), typeof(object));
}
return BindingHelpers.AddDynamicTestAndDefer(
convertToAction,
new DynamicMetaObject(
Ast.Condition(
MakeTryGetTypeMember(
PythonContext.GetPythonContext(convertToAction),
pts,
self.Expression,
tmp
),
callExpr,
AstUtils.Convert(
ConversionFallback(convertToAction),
typeof(object)
)
),
self.Restrict(self.GetRuntimeType()).Restrictions
),
new DynamicMetaObject[] { this },
valInfo,
tmp
);
}
return fallback();
}
private DynamicMetaObject TryToCharConversion(DynamicMetaObject /*!*/ self)
{
DynamicMetaObject res;
// we have an implicit conversion to char if the
// string length == 1, but we can only represent
// this is implicit via a rule.
string strVal = self.Value as string;
Expression strExpr = self.Expression;
if (strVal == null)
{
Extensible <string> extstr = self.Value as Extensible <string>;
if (extstr != null)
{
strVal = extstr.Value;
strExpr =
Ast.Property(
AstUtils.Convert(
strExpr,
typeof(Extensible <string>)
),
typeof(Extensible <string>).GetProperty("Value")
);
}
}
// we can only produce a conversion if we have a string value...
if (strVal != null)
{
self = self.Restrict(self.GetRuntimeType());
Expression getLen = Ast.Property(
AstUtils.Convert(
strExpr,
typeof(string)
),
typeof(string).GetProperty("Length")
);
if (strVal.Length == 1)
{
res = new DynamicMetaObject(
Ast.Call(
AstUtils.Convert(strExpr, typeof(string)),
typeof(string).GetMethod("get_Chars"),
AstUtils.Constant(0)
),
self.Restrictions.Merge(BindingRestrictions.GetExpressionRestriction(Ast.Equal(getLen, AstUtils.Constant(1))))
);
}
else
{
res = new DynamicMetaObject(
Ast.Throw(
Ast.Call(
typeof(PythonOps).GetMethod("TypeError"),
AstUtils.Constant("expected string of length 1 when converting to char, got '{0}'"),
Ast.NewArrayInit(typeof(object), self.Expression)
),
ReturnType
),
self.Restrictions.Merge(BindingRestrictions.GetExpressionRestriction(Ast.NotEqual(getLen, AstUtils.Constant(1))))
);
}
}
else
{
// let the base class produce the rule
res = null;
}
return(res);
}
private DynamicMetaObject/*!*/ MakeConvertRuleForCall(ConvertBinder/*!*/ convertToAction, DynamicMetaObject/*!*/ self, SymbolId symbolId, string returner) {
PythonType pt = ((IPythonObject)self.Value).PythonType;
PythonTypeSlot pts;
CodeContext context = BinderState.GetBinderState(convertToAction).Context;
if (pt.TryResolveSlot(context, symbolId, out pts) && !IsBuiltinConversion(context, pts, symbolId, pt)) {
ParameterExpression tmp = Ast.Variable(typeof(object), "func");
Expression callExpr = Ast.Call(
PythonOps.GetConversionHelper(returner, GetResultKind(convertToAction)),
Ast.Dynamic(
new PythonInvokeBinder(
BinderState.GetBinderState(convertToAction),
new CallSignature(0)
),
typeof(object),
BinderState.GetCodeContext(convertToAction),
tmp
)
);
if (typeof(Extensible<>).MakeGenericType(convertToAction.Type).IsAssignableFrom(self.GetLimitType())) {
// if we're doing a conversion to the underlying type and we're an
// Extensible<T> of that type:
// if an extensible type returns it's self in a conversion, then we need
// to actually return the underlying value. If an extensible just keeps
// returning more instances of it's self a stack overflow occurs - both
// behaviors match CPython.
callExpr = AstUtils.Convert(AddExtensibleSelfCheck(convertToAction, self, callExpr), typeof(object));
}
return new DynamicMetaObject(
Ast.Block(
new ParameterExpression[] { tmp },
Ast.Condition(
BindingHelpers.CheckTypeVersion(
self.Expression,
pt.Version
),
Ast.Condition(
MakeTryGetTypeMember(
BinderState.GetBinderState(convertToAction),
pts,
self.Expression,
tmp
),
callExpr,
AstUtils.Convert(
ConversionFallback(convertToAction),
typeof(object)
)
),
convertToAction.Defer(this).Expression
)
),
self.Restrict(self.GetRuntimeType()).Restrictions
);
}
return convertToAction.FallbackConvert(this);
}
