internal override Expression AsExpression(Expression target)
{
RequireNoValueProperty();
Expression member = MemberExpression.Make(target, _binding.Member);
Expression memberTemp = _spiller.MakeTemp(member.Type);
int count = _bindings.Count;
Expression[] block = new Expression[count + 2];
block[0] = new AssignBinaryExpression(memberTemp, member);
for (int i = 0; i < count; i++)
{
BindingRewriter br = _bindingRewriters[i];
block[i + 1] = br.AsExpression(memberTemp);
}
// We need to copy back value types.
if (memberTemp.Type.IsValueType)
{
block[count + 1] = Expression.Block(
typeof(void),
new AssignBinaryExpression(MemberExpression.Make(target, _binding.Member), memberTemp)
);
}
else
{
block[count + 1] = Utils.Empty;
}
return(MakeBlock(block));
}
internal override Expression AsExpression(Expression target)
{
if (target.Type.IsValueType && _binding.Member is System.Reflection.PropertyInfo)
{
throw Error.CannotAutoInitializeValueTypeMemberThroughProperty(_binding.Member);
}
RequireNotRefInstance(target);
MemberExpression member = Expression.MakeMemberAccess(target, _binding.Member);
ParameterExpression memberTemp = _spiller.MakeTemp(member.Type);
Expression[] block = new Expression[_bindings.Count + 2];
block[0] = Expression.Assign(memberTemp, member);
for (int i = 0; i < _bindings.Count; i++)
{
BindingRewriter br = _bindingRewriters[i];
block[i + 1] = br.AsExpression(memberTemp);
}
// We need to copy back value types
if (memberTemp.Type.IsValueType)
{
block[_bindings.Count + 1] = Expression.Block(
typeof(void),
Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp)
);
}
else
{
block[_bindings.Count + 1] = Expression.Empty();
}
return(MakeBlock(block));
}
internal override Expression AsExpression(Expression target)
{
RequireNoValueProperty();
RequireNotRefInstance(target);
MemberExpression member = Expression.MakeMemberAccess(target, _binding.Member);
ParameterExpression memberTemp = _spiller.MakeTemp(member.Type);
Expression[] block = new Expression[_bindings.Count + 2];
block[0] = Expression.Assign(memberTemp, member);
for (int i = 0; i < _bindings.Count; i++)
{
BindingRewriter br = _bindingRewriters[i];
block[i + 1] = br.AsExpression(memberTemp);
}
// We need to copy back value types
if (memberTemp.Type.GetTypeInfo().IsValueType)
{
block[_bindings.Count + 1] = Expression.Block(
typeof(void),
Expression.Assign(Expression.MakeMemberAccess(target, _binding.Member), memberTemp)
);
}
else
{
block[_bindings.Count + 1] = Utils.Empty();
}
return(MakeBlock(block));
}
private Result RewriteMemberInitExpression(Expression expr, Stack stack)
{
var node = (MemberInitExpression)expr;
// Constructor runs on initial stack.
Result result = RewriteExpression(node.NewExpression, stack);
Expression rewrittenNew = result.Node;
RewriteAction action = result.Action;
ReadOnlyCollection <MemberBinding> bindings = node.Bindings;
BindingRewriter[] bindingRewriters = new BindingRewriter[bindings.Count];
for (int i = 0; i < bindings.Count; i++)
{
MemberBinding binding = bindings[i];
// Bindings run on non-empty stack (the object instance is on it).
BindingRewriter rewriter = BindingRewriter.Create(binding, this, Stack.NonEmpty);
bindingRewriters[i] = rewriter;
action |= rewriter.Action;
}
switch (action)
{
case RewriteAction.None:
break;
case RewriteAction.Copy:
MemberBinding[] newBindings = new MemberBinding[bindings.Count];
for (int i = 0; i < bindings.Count; i++)
{
newBindings[i] = bindingRewriters[i].AsBinding();
}
expr = new MemberInitExpression((NewExpression)rewrittenNew, new TrueReadOnlyCollection <MemberBinding>(newBindings));
break;
case RewriteAction.SpillStack:
RequireNotRefInstance(node.NewExpression);
ParameterExpression tempNew = MakeTemp(rewrittenNew.Type);
Expression[] comma = new Expression[bindings.Count + 2];
comma[0] = new AssignBinaryExpression(tempNew, rewrittenNew);
for (int i = 0; i < bindings.Count; i++)
{
BindingRewriter cr = bindingRewriters[i];
Expression initExpr = cr.AsExpression(tempNew);
comma[i + 1] = initExpr;
}
comma[bindings.Count + 1] = tempNew;
expr = MakeBlock(comma);
break;
default:
throw ContractUtils.Unreachable;
}
return(new Result(action, expr));
}
// RewriteMemberInitExpression
private Result RewriteMemberInitExpression(Expression expr, Stack stack)
{
var node = (MemberInitExpression)expr;
//ctor runs on original stack
var result = RewriteExpression(node.NewExpression, stack);
var rewrittenNew = result.Node;
var action = result.Action;
var bindings = node.Bindings;
var bindingRewriters = new BindingRewriter[bindings.Count];
for (var i = 0; i < bindings.Count; i++)
{
var binding = bindings[i];
//bindings run on nonempty stack
var rewriter = BindingRewriter.Create(binding, this, Stack.NonEmpty);
bindingRewriters[i] = rewriter;
action |= rewriter.Action;
}
switch (action)
{
case RewriteAction.None:
break;
case RewriteAction.Copy:
var newBindings = new MemberBinding[bindings.Count];
for (var i = 0; i < bindings.Count; i++)
{
newBindings[i] = bindingRewriters[i].AsBinding();
}
expr = Expression.MemberInit((NewExpression)rewrittenNew, new TrueReadOnlyCollection <MemberBinding>(newBindings));
break;
case RewriteAction.SpillStack:
RequireNotRefInstance(node.NewExpression);
var tempNew = MakeTemp(rewrittenNew.Type);
var comma = new Expression[bindings.Count + 2];
comma[0] = Expression.Assign(tempNew, rewrittenNew);
for (var i = 0; i < bindings.Count; i++)
{
var cr = bindingRewriters[i];
var initExpr = cr.AsExpression(tempNew);
comma[i + 1] = initExpr;
}
comma[bindings.Count + 1] = tempNew;
expr = MakeBlock(comma);
break;
default:
throw ContractUtils.Unreachable;
}
return(new Result(action, expr));
}
// RewriteMemberInitExpression
private Result RewriteMemberInitExpression(Expression expr, Stack stack)
{
MemberInitExpression node = (MemberInitExpression)expr;
//ctor runs on original stack
Result result = RewriteExpression(node.NewExpression, stack);
Expression rewrittenNew = result.Node;
RewriteAction action = result.Action;
ReadOnlyCollection <MemberBinding> bindings = node.Bindings;
BindingRewriter[] bindingRewriters = new BindingRewriter[bindings.Count];
for (int i = 0; i < bindings.Count; i++)
{
MemberBinding binding = bindings[i];
//bindings run on nonempty stack
BindingRewriter rewriter = BindingRewriter.Create(binding, this, Stack.NonEmpty);
bindingRewriters[i] = rewriter;
action |= rewriter.Action;
}
switch (action)
{
case RewriteAction.None:
break;
case RewriteAction.Copy:
MemberBinding[] newBindings = new MemberBinding[bindings.Count];
for (int i = 0; i < bindings.Count; i++)
{
newBindings[i] = bindingRewriters[i].AsBinding();
}
expr = Expression.MemberInit((NewExpression)rewrittenNew, new ReadOnlyCollection <MemberBinding>(newBindings));
break;
case RewriteAction.SpillStack:
ParameterExpression tempNew = MakeTemp(rewrittenNew.Type);
Expression[] comma = new Expression[bindings.Count + 2];
comma[0] = Expression.Assign(tempNew, rewrittenNew);
for (int i = 0; i < bindings.Count; i++)
{
BindingRewriter cr = bindingRewriters[i];
Expression initExpr = cr.AsExpression(tempNew);
comma[i + 1] = initExpr;
}
comma[bindings.Count + 1] = tempNew;
expr = Expression.Block(comma);
break;
default:
throw Assert.Unreachable;
}
return(new Result(action, expr));
}
internal MemberMemberBindingRewriter(MemberMemberBinding binding, StackSpiller spiller, Stack stack) :
base(binding, spiller)
{
_bindings = binding.Bindings;
_bindingRewriters = new BindingRewriter[_bindings.Count];
for (int i = 0; i < _bindings.Count; i++)
{
BindingRewriter br = BindingRewriter.Create(_bindings[i], spiller, stack);
_action |= br.Action;
_bindingRewriters[i] = br;
}
}
internal static ValueTask <Validation <string, Func <CancellationToken, TResult> > > CompileQuery <TSourceDescription, TResult>(
Expression expression,
Verifier verify,
Authorizer <TSourceDescription> authorize,
IReadOnlyDictionary <string, TSourceDescription> bindings,
Func <Expression, Expression> boxingRewriter) where TSourceDescription : IQueryableSourceDescription =>
from verified in verify(expression).ToValueTask()
let unboundParameters = Scanners.FindUnboundParameters(expression)
from methodBindings in BindMethods(unboundParameters, bindings).ToValueTask()
from authorized in authorize(methodBindings.Values)
let lambdaBindings = BindLambdas(methodBindings)
let syntheticParameters = new[] { Expression.Parameter(typeof(CancellationToken)) }
from invocationBindings in BindInvocations(lambdaBindings, syntheticParameters).ToValueTask()
let boundQuery = BindingRewriter.Rewrite(expression, invocationBindings)
let boxedQuery = boxingRewriter(boundQuery)
select Expression.Lambda <Func <CancellationToken, TResult> >(boxedQuery, syntheticParameters).Compile();
private Result RewriteMemberInitExpression(Expression expr, Stack stack)
{
var node = (MemberInitExpression)expr;
// Constructor runs on initial stack.
Result result = RewriteExpression(node.NewExpression, stack);
Expression rewrittenNew = result.Node;
RewriteAction action = result.Action;
ReadOnlyCollection <MemberBinding> bindings = node.Bindings;
int count = bindings.Count;
BindingRewriter[] bindingRewriters = new BindingRewriter[count];
for (int i = 0; i < count; i++)
{
MemberBinding binding = bindings[i];
// Bindings run on non-empty stack (the object instance is on it).
BindingRewriter rewriter = BindingRewriter.Create(binding, this, Stack.NonEmpty);
bindingRewriters[i] = rewriter;
action |= rewriter.Action;
}
switch (action)
{
case RewriteAction.None:
break;
case RewriteAction.Copy:
MemberBinding[] newBindings = new MemberBinding[count];
for (int i = 0; i < count; i++)
{
newBindings[i] = bindingRewriters[i].AsBinding();
}
expr = new MemberInitExpression((NewExpression)rewrittenNew, new TrueReadOnlyCollection <MemberBinding>(newBindings));
break;
case RewriteAction.SpillStack:
bool isRefNew = IsRefInstance(node.NewExpression);
var comma = new ArrayBuilder <Expression>(count + 2 + (isRefNew ? 1 : 0));
ParameterExpression tempNew = MakeTemp(rewrittenNew.Type);
comma.UncheckedAdd(new AssignBinaryExpression(tempNew, rewrittenNew));
ParameterExpression refTempNew = tempNew;
if (isRefNew)
{
refTempNew = MakeTemp(tempNew.Type.MakeByRefType());
comma.UncheckedAdd(new ByRefAssignBinaryExpression(refTempNew, tempNew));
}
for (int i = 0; i < count; i++)
{
BindingRewriter cr = bindingRewriters[i];
Expression initExpr = cr.AsExpression(refTempNew);
comma.UncheckedAdd(initExpr);
}
comma.UncheckedAdd(tempNew);
expr = MakeBlock(comma);
break;
default:
throw ContractUtils.Unreachable;
}
return(new Result(action, expr));
}