internal protected override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed)
{
Debug.Assert(hasBeenUsed.Length == args.Length);
Debug.Assert(_index < args.Length);
Debug.Assert(!hasBeenUsed[Index]);
hasBeenUsed[_index] = true;
return(resolver.Convert(args.GetObject(_index), args.GetType(_index), ParameterInfo, _parameterType));
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference")] // TODO
internal protected virtual Expression ToExpression(ref MethodInfo method, OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed)
{
if (_index == -1)
{
return(AstUtils.Constant(null));
}
Debug.Assert(hasBeenUsed.Length == args.Length);
Debug.Assert(_index < args.Length);
Debug.Assert(!hasBeenUsed[_index]);
hasBeenUsed[_index] = true;
GetCallableMethod(args, ref method);
return(resolver.Convert(args.GetObject(_index), args.GetType(_index), null, method.DeclaringType));
}
public override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed)
{
object value = ParameterInfo.GetDefaultValue();
if (value is Missing)
{
value = CompilerHelpers.GetMissingValue(ParameterInfo.ParameterType);
}
if (ParameterInfo.ParameterType.IsByRef)
{
return(AstUtils.Constant(value, ParameterInfo.ParameterType.GetElementType()));
}
var metaValue = new DynamicMetaObject(AstUtils.Constant(value), BindingRestrictions.Empty, value);
return(resolver.Convert(metaValue, CompilerHelpers.GetType(value), ParameterInfo, ParameterInfo.ParameterType));
}
internal protected override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed)
{
var actualArgs = resolver.GetActualArguments();
int splatIndex = actualArgs.SplatIndex;
int collapsedCount = actualArgs.CollapsedCount;
int firstSplatted = actualArgs.FirstSplattedArg;
var result = new Expression[2 + _expandedCount + (collapsedCount > 0 ? 2 : 0)];
var arrayVariable = resolver.GetTemporary(_elementType.MakeArrayType(), "a");
int e = 0;
result[e++] = Ast.Assign(arrayVariable, Ast.NewArrayBounds(_elementType, Ast.Constant(_expandedCount + collapsedCount)));
int itemIndex = 0;
int i = _start;
while (true)
{
// inject loop copying collapsed items:
if (i == splatIndex)
{
var indexVariable = resolver.GetTemporary(typeof(int), "t");
// for (int t = 0; t <= {collapsedCount}; t++) {
// a[{itemIndex} + t] = CONVERT<ElementType>(list.get_Item({splatIndex - firstSplatted} + t))
// }
result[e++] = Ast.Assign(indexVariable, AstUtils.Constant(0));
result[e++] = AstUtils.Loop(
Ast.LessThan(indexVariable, Ast.Constant(collapsedCount)),
// TODO: not implemented in the old interpreter
// Ast.PostIncrementAssign(indexVariable),
Ast.Assign(indexVariable, Ast.Add(indexVariable, AstUtils.Constant(1))),
Ast.Assign(
Ast.ArrayAccess(arrayVariable, Ast.Add(AstUtils.Constant(itemIndex), indexVariable)),
resolver.Convert(
new DynamicMetaObject(
resolver.GetSplattedItemExpression(Ast.Add(AstUtils.Constant(splatIndex - firstSplatted), indexVariable)),
BindingRestrictions.Empty
),
null,
ParameterInfo,
_elementType
)
),
null
);
itemIndex += collapsedCount;
}
if (i >= _start + _expandedCount)
{
break;
}
Debug.Assert(!hasBeenUsed[i]);
hasBeenUsed[i] = true;
result[e++] = Ast.Assign(
Ast.ArrayAccess(arrayVariable, AstUtils.Constant(itemIndex++)),
resolver.Convert(args.GetObject(i), args.GetType(i), ParameterInfo, _elementType)
);
i++;
}
result[e++] = arrayVariable;
Debug.Assert(e == result.Length);
return(Ast.Block(result));
}