internal override Expression UpdateFromReturn(MethodBinderContext context, Expression[] parameters) {
return Ast.Call(
typeof(BinderOps).GetMethod("UpdateBox").MakeGenericMethod(_elementType),
Ast.Convert(parameters[Index], BoxType),
Ast.Read(_tmp)
);
}
internal override Expression ToReturnExpression(MethodBinderContext context) {
if (_isRef) {
return Ast.Read(_tmp);
}
return GetDefaultValue();
}
internal override Expression ToExpression(MethodBinderContext context, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret)
{
List<Expression> sets = new List<Expression>();
Variable tmp = null;// context.GetTemporary(ret.Type, "val");
for (int i = 0; i < _indexesUsed.Length; i++) {
Expression value = parameters[parameters.Count - _kwArgCount + _indexesUsed[i]];
switch(_membersSet[i].MemberType) {
case MemberTypes.Field:
FieldInfo fi = (FieldInfo)_membersSet[i];
if (!fi.IsLiteral && !fi.IsInitOnly) {
sets.Add(Ast.AssignField(Ast.Read(tmp), fi, Ast.ConvertHelper(value, fi.FieldType)));
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(RuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(true),
Ast.Constant(fi.Name)
),
fi.FieldType
)
);
}
break;
case MemberTypes.Property:
PropertyInfo pi = (PropertyInfo)_membersSet[i];
if (pi.GetSetMethod(ScriptDomainManager.Options.PrivateBinding) != null) {
sets.Add(Ast.AssignProperty(Ast.Read(tmp), pi, Ast.ConvertHelper(value, pi.PropertyType)));
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(RuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(false),
Ast.Constant(pi.Name)
),
pi.PropertyType
)
);
}
break;
}
}
Expression newCall = Ast.Comma(
0,
ArrayUtils.Insert<Expression>(
Ast.Assign(tmp, ret),
sets.ToArray()
)
);
return _builder.ToExpression(context, args, parameters, newCall);
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters) {
Expression res = Ast.Call(
typeof(BinderOps).GetMethod("MakeSymbolDictionary"),
Ast.NewArray(typeof(SymbolId[]), ConstantNames()),
Ast.NewArrayHelper(typeof(object[]), GetParameters(parameters))
);
return res;
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_tmp == null) {
_tmp = context.GetTemporary(Type, "outParam");
}
#endif
return Ast.Comma(Ast.Assign(_tmp, base.ToExpression(context, parameters)), Ast.Read(_tmp));
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_isRef) {
if (_tmp == null) {
_tmp = context.GetTemporary(_parameterType, "outParam");
}
return Ast.Read(_tmp);
}
#endif
return GetDefaultValue();
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
#if FULL
if (_tmp == null) {
_tmp = context.GetTemporary(_elementType, "outParam");
}
#endif
// Ideally we'd pass in Ast.ReadField(parameters[Index], "Value") but due to
// a bug in partial trust we can't access the generic field.
// arg is boxType ? &_tmp : throw new ArgumentTypeException()
// IncorrectBoxType throws the exception to avoid stack imbalance issues.
return Ast.Condition(
Ast.TypeIs(parameters[Index], BoxType),
Ast.Comma(
Ast.Assign(
_tmp,
Ast.Call(
typeof(BinderOps).GetMethod("GetBox").MakeGenericMethod(_elementType),
Ast.ConvertHelper(parameters[Index], typeof(StrongBox<>).MakeGenericType(_elementType))
)
),
Ast.Read(_tmp)
),
// Condition requires types of both expressions to be identical.
// Putting the cast here is a temporary workaround until the
// emit address and reference argument passing is finished.
Ast.Convert(
Ast.Call(
typeof(BinderOps).GetMethod("IncorrectBoxType"),
Ast.Constant(BoxType),
Ast.ConvertHelper(parameters[Index], typeof(object))
),
_elementType
)
);
}
internal override Expression ToExpression(MethodBinderContext context, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret)
{
if (_returnArgs.Count == 1) {
if (_returnArgs[0] == -1) {
return ret;
}
return Ast.Comma(ret, args[_returnArgs[0]].ToReturnExpression(context));
}
Expression[] retValues = new Expression[_returnArgs.Count];
int rIndex = 0;
bool usesRet = false;
foreach (int index in _returnArgs) {
if (index == -1) {
usesRet = true;
retValues[rIndex++] = ret;
} else {
retValues[rIndex++] = args[index].ToReturnExpression(context);
}
}
Expression retArray = Ast.NewArrayHelper(typeof(object[]), retValues);
if (!usesRet) {
retArray = Ast.Comma(ret, retArray);
}
return Ast.Call(
Ast.ReadProperty(
Ast.ReadProperty(
Ast.CodeContext(),
typeof(CodeContext).GetProperty("LanguageContext")
),
typeof(LanguageContext).GetProperty("Binder")
),
typeof(ActionBinder).GetMethod("GetByRefArray"),
retArray
);
}
/// <summary>
/// Provides an Expression which will update the provided value after a call to the method. May
/// return null if no update is required.
/// </summary>
internal virtual Expression UpdateFromReturn(MethodBinderContext context, Expression[] parameters)
{
return(null);
}
internal override Expression ToReturnExpression(MethodBinderContext context)
{
return(Ast.Read(_tmp));
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
Debug.Assert(_index < parameters.Length);
Debug.Assert(parameters[_index] != null);
return(context.ConvertExpression(parameters[_index], _parameterType));
}
/// <summary>
/// If the argument produces a return value (e.g. a ref or out value) this provides
/// the additional value to be returned.
/// </summary>
internal virtual Expression ToReturnExpression(MethodBinderContext context) {
throw new InvalidOperationException();
}
internal override Expression CheckExpression(MethodBinderContext context, Expression[] parameters)
{
return context.CheckExpression(parameters[_index], _parameterType);
}
internal override Expression CheckExpression(MethodBinderContext context, Expression[] parameters)
{
return(null);
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
return Ast.Comma(Ast.Assign(_tmp, base.ToExpression(context, parameters)), Ast.Read(_tmp));
}
internal override Expression UpdateFromReturn(MethodBinderContext context, Expression[] parameters)
{
return _builder.UpdateFromReturn(context, new Expression[] { parameters[GetKeywordIndex(parameters.Length)] });
}
internal override Expression ToReturnExpression(MethodBinderContext context)
{
return _builder.ToReturnExpression(context);
}
public Expression MakeExpression(ActionBinder binder, StandardRule rule, Expression[] parameters)
{
MethodBinderContext context = new MethodBinderContext(binder, rule);
Expression check = Ast.True();
if (_binder.IsBinaryOperator)
{
// TODO: only if we have a narrowing level
// need to emit check to see if args are convertible...
for (int i = 0; i < _argBuilders.Count; i++)
{
Expression checkedExpr = _argBuilders[i].CheckExpression(context, parameters);
if (checkedExpr != null)
{
check = Ast.AndAlso(check, checkedExpr);
}
}
}
Expression[] args = new Expression[_argBuilders.Count];
for (int i = 0; i < _argBuilders.Count; i++)
{
args[i] = _argBuilders[i].ToExpression(context, parameters);
}
MethodInfo mi = Method as MethodInfo;
Expression ret, call;
if (!Method.IsPublic || !Method.DeclaringType.IsVisible)
{
if (mi != null)
{
mi = CompilerHelpers.GetCallableMethod(mi);
}
}
if (Method.IsPublic && Method.DeclaringType.IsVisible)
{
// public method
if (mi != null)
{
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.SimpleCallHelper(instance, mi, args);
}
else
{
call = Ast.SimpleNewHelper((ConstructorInfo)Method, args);
}
}
else
{
// Private binding, invoke via reflection
if (mi != null)
{
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.Call(
Ast.RuntimeConstant(mi),
typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }),
Ast.ConvertHelper(instance, typeof(object)),
Ast.NewArrayHelper(typeof(object[]), args)
);
}
else
{
call = Ast.Call(
Ast.RuntimeConstant((ConstructorInfo)Method),
typeof(ConstructorInfo).GetMethod("Invoke", new Type[] { typeof(object[]) }),
Ast.NewArrayHelper(typeof(object[]), args)
);
}
}
ret = _returnBuilder.ToExpression(context, _argBuilders, parameters, call);
List <Expression> updates = null;
for (int i = 0; i < _argBuilders.Count; i++)
{
Expression next = _argBuilders[i].UpdateFromReturn(context, parameters);
if (next != null)
{
if (updates == null)
{
updates = new List <Expression>();
}
updates.Add(next);
}
}
if (updates != null)
{
updates.Insert(0, ret);
ret = Ast.Comma(0, updates.ToArray());
}
if (!check.IsConstant(true))
{
ret = Ast.Condition(
check,
Ast.ConvertHelper(ret, typeof(object)),
GetNotImplemented()
);
}
return(ret);
}
internal virtual Expression ToExpression(MethodBinderContext context, IList <ArgBuilder> args, IList <Expression> parameters, Expression ret)
{
return(ret);
}
internal override Expression CheckExpression(MethodBinderContext context, Expression[] parameters)
{
return(context.CheckExpression(parameters[_index], _parameterType));
}
internal override Expression ToReturnExpression(MethodBinderContext context) {
return Ast.Read(_tmp);
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters) {
object val = _defaultValue;
if(val is Missing) {
val = CompilerHelpers.GetMissingValue(_argumentType);
}
#if FULL
if (_argumentType.IsByRef) {
Variable tmp = context.GetTemporary(_argumentType.GetElementType(), "optRef");
return Ast.Comma(
Ast.Assign(
tmp,
Ast.Convert(Ast.Constant(val), tmp.Type)
),
Ast.Read(tmp)
);
}
#endif
return context.ConvertExpression(Ast.Constant(val), _argumentType);
}
internal virtual Expression ToExpression(MethodBinderContext context, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret)
{
return ret;
}
/// <summary> /// Provides an Expression which returns a Boolean determining whether or not the parameter is convertible /// to the receiving arguments type. This is currently only used for a MethodBinder of BinderType.BinaryOperator. /// /// This function should be removed when BinaryOperator support is removed. /// </summary> internal abstract Expression CheckExpression(MethodBinderContext context, Expression[] parameters);
internal override Expression CheckExpression(MethodBinderContext context, Expression[] parameters) {
return null;
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
return(GetDefaultValue());
}
/// <summary>
/// Provides an Expression which will update the provided value after a call to the method. May
/// return null if no update is required.
/// </summary>
internal virtual Expression UpdateFromReturn(MethodBinderContext context, Expression[] parameters) {
return null;
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
Debug.Assert(_index < parameters.Length);
Debug.Assert(parameters[_index] != null);
return context.ConvertExpression(parameters[_index], _parameterType);
}
public Expression MakeExpression(ActionBinder binder, StandardRule rule, Expression[] parameters) {
MethodBinderContext context = new MethodBinderContext(binder, rule);
Expression check = Ast.True();
if (_binder.IsBinaryOperator) {
// TODO: only if we have a narrowing level
// need to emit check to see if args are convertible...
for (int i = 0; i < _argBuilders.Count; i++) {
Expression checkedExpr = _argBuilders[i].CheckExpression(context, parameters);
if(checkedExpr != null) {
check = Ast.AndAlso(check, checkedExpr);
}
}
}
Expression[] args = new Expression[_argBuilders.Count];
for (int i = 0; i < _argBuilders.Count; i++) {
args[i] = _argBuilders[i].ToExpression(context, parameters);
}
MethodInfo mi = Method as MethodInfo;
Expression ret, call;
if (!Method.IsPublic || !Method.DeclaringType.IsVisible) {
if (mi != null) {
mi = CompilerHelpers.GetCallableMethod(mi);
}
}
if (Method.IsPublic && Method.DeclaringType.IsVisible) {
// public method
if (mi != null) {
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.SimpleCallHelper(instance, mi, args);
} else {
call = Ast.SimpleNewHelper((ConstructorInfo)Method, args);
}
} else {
// Private binding, invoke via reflection
if (mi != null) {
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(context, parameters);
call = Ast.Call(
Ast.RuntimeConstant(mi),
typeof(MethodInfo).GetMethod("Invoke", new Type[] { typeof(object), typeof(object[]) }),
Ast.ConvertHelper(instance, typeof(object)),
Ast.NewArrayHelper(typeof(object[]), args)
);
} else {
call = Ast.Call(
Ast.RuntimeConstant((ConstructorInfo)Method),
typeof(ConstructorInfo).GetMethod("Invoke", new Type[] { typeof(object[]) }),
Ast.NewArrayHelper(typeof(object[]), args)
);
}
}
ret = _returnBuilder.ToExpression(context, _argBuilders, parameters, call);
List<Expression> updates = null;
for (int i = 0; i < _argBuilders.Count; i++) {
Expression next = _argBuilders[i].UpdateFromReturn(context, parameters);
if (next != null) {
if (updates == null) updates = new List<Expression>();
updates.Add(next);
}
}
if (updates != null) {
updates.Insert(0, ret);
ret = Ast.Comma(0, updates.ToArray());
}
if (!check.IsConstant(true)) {
ret = Ast.Condition(
check,
Ast.ConvertHelper(ret, typeof(object)),
GetNotImplemented()
);
}
return ret;
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
return(Ast.Comma(Ast.Assign(_tmp, base.ToExpression(context, parameters)), Ast.Read(_tmp)));
}
/// <summary>
/// If the argument produces a return value (e.g. a ref or out value) this provides
/// the additional value to be returned.
/// </summary>
internal virtual Expression ToReturnExpression(MethodBinderContext context)
{
throw new InvalidOperationException();
}
internal override Expression ToExpression(MethodBinderContext context, Expression[] parameters)
{
object val = _defaultValue;
if(val is Missing) {
val = CompilerHelpers.GetMissingValue(_argumentType);
}
return context.ConvertExpression(Ast.Constant(val), _argumentType);
}
/// <summary> /// Provides an Expression which returns a Boolean determining whether or not the parameter is convertible /// to the receiving arguments type. This is currently only used for a MethodBinder of BinderType.BinaryOperator. /// /// This function should be removed when BinaryOperator support is removed. /// </summary> internal abstract Expression CheckExpression(MethodBinderContext context, Expression[] parameters);
