public ClosureExpression(Ast.PythonVariable/*!*/ variable, Expression/*!*/ closureCell, ParameterExpression parameter) {
Assert.NotNull(closureCell);
_variable = variable;
_closureCell = closureCell;
_parameter = parameter;
}
public override Ast ConvertExpression(Ast expr, Type toType, ConversionResultKind kind, OverloadResolverFactory resolverFactory)
{
Type exprType = expr.Type;
Type visType = CompilerHelpers.GetVisibleType(toType);
if (typeof(IFn).IsAssignableFrom(exprType) && typeof(Delegate).IsAssignableFrom(visType))
return Ast.Call(typeof(Converter).GetMethod("ConvertToDelegate"), Ast.Convert(expr, typeof(IFn)), Expression.Constant(visType));
// Follow through on our promise to convert IEnumerable<Object> or IEnumerable to IEnumerable<T> for any T
if (toType.IsGenericType && ! toType.IsAssignableFrom(expr.Type))
{
// The following is inspired by IronPython.Runtime.Binding.Python.ConversionBinder.FallbackConvert
Type genTo = toType.GetGenericTypeDefinition();
if ( genTo == typeof(IList<>))
{
return MakeToGenericConversion(expr,toType,typeof(IList<object>),typeof(ListGenericWrapper<>));
}
else if (genTo == typeof(IDictionary<,>))
{
return MakeToGenericConversion(expr,toType,typeof(IDictionary<object,object>),typeof(DictionaryGenericWrapper<,>));
}
else if (genTo == typeof(IEnumerable<>))
{
return MakeToGenericConversion(expr, toType, typeof(IEnumerable),typeof(IEnumerableOfTWrapper<>));
}
}
return base.ConvertExpression(expr, toType, kind, resolverFactory);
}
public PythonGlobalVariableExpression(Expression/*!*/ globalExpr, Ast.PythonVariable/*!*/ variable, PythonGlobal/*!*/ global) {
Assert.NotNull(globalExpr, variable);
_target = globalExpr;
_global = global;
_variable = variable;
}
internal PythonGlobalVariableExpression(Expression/*!*/ globalExpr, Ast.PythonVariable/*!*/ variable, PythonGlobal/*!*/ global, bool lightEh) {
Assert.NotNull(globalExpr, variable);
_target = globalExpr;
_global = global;
_variable = variable;
_lightEh = lightEh;
}
public override Ast ConvertExpression(Ast expr, Type toType, ConversionResultKind kind, OverloadResolverFactory resolverFactory)
{
Type exprType = expr.Type;
Type visType = CompilerHelpers.GetVisibleType(toType);
if (typeof(IFn).IsAssignableFrom(exprType) && typeof(Delegate).IsAssignableFrom(visType))
return Ast.Call(typeof(Converter).GetMethod("ConvertToDelegate"), Ast.Convert(expr, typeof(IFn)), Expression.Constant(visType));
return base.ConvertExpression(expr, toType, kind, resolverFactory);
}
internal Ast AddVariables(Ast expression) {
ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
MSAst.ParameterExpression localContext = null;
if (NeedsLocalContext) {
localContext = _compContext;
locals.Add(_compContext);
}
List<MSAst.Expression> body = new List<MSAst.Expression>();
CreateVariables(locals, body);
if (localContext != null) {
var createLocal = CreateLocalContext(_comprehension.Parent.LocalContext);
body.Add(Ast.Assign(_compContext, createLocal));
body.Add(expression);
} else {
body.Add(expression);
}
return Expression.Block(
locals,
body
);
}
DynamicMetaObject/*!*/ IDynamicMetaObjectProvider.GetMetaObject(Ast/*!*/ parameter) {
return new Binding.MetaPythonFunction(parameter, BindingRestrictions.Empty, this);
}
private static Ast MakeToGenericConversion(Ast expr, Type toType, Type fromType, Type wrapperType)
{
Type destType = wrapperType.MakeGenericType(toType.GetGenericArguments());
return Ast.New(
destType.GetConstructor(new Type[] { fromType }),
AstUtils.Convert(expr, fromType));
}
public PythonGlobalVariableExpression(Expression/*!*/ globalExpr, Ast.PythonVariable/*!*/ variable, PythonGlobal/*!*/ global)
: this(globalExpr, variable, global, false) {
}
