/// <summary>Rebinds the specified member access expression into a path-based value retrieval method call.</summary>
/// <param name='m'>Member expression.</param>
/// <param name='baseAnnotation'>Annotation for the base portion of the expression.</param>
/// <returns>A rebound expression.</returns>
private Expression RebindMemberAccess(MemberExpression m, ExpressionAnnotation baseAnnotation)
{
Debug.Assert(m != null, "m != null");
Debug.Assert(baseAnnotation != null, "baseAnnotation != null");
ProjectionPathSegment memberSegment;
// If we are in nested member-init, we rewrite the property
// accessors that are in the form of top.nested.id to
// nested.id.
Expression baseSourceExpression = m.Expression;
Expression result = this.pathBuilder.GetRewrite(baseSourceExpression);
if (result != null)
{
Expression baseTypeExpression = Expression.Constant(baseSourceExpression.Type, typeof(Type));
ProjectionPath nestedPath = new ProjectionPath(result as ParameterExpression, baseTypeExpression, result);
ProjectionPathSegment nestedSegment = new ProjectionPathSegment(nestedPath, m);
nestedPath.Add(nestedSegment);
result = this.CallValueForPathWithType(result, baseTypeExpression, nestedPath, m.Type);
}
else
{
// This actually modifies the path for the underlying
// segments, but that shouldn't be a problem. Actually
// we should be able to remove it from the dictionary.
// There should be no aliasing problems, because
// annotations always come from target expression
// that are generated anew (except parameters,
// but those)
memberSegment = new ProjectionPathSegment(baseAnnotation.Segment.StartPath, m);
baseAnnotation.Segment.StartPath.Add(memberSegment);
result = this.CallValueForPathWithType(
baseAnnotation.Segment.StartPath.RootEntry,
baseAnnotation.Segment.StartPath.ExpectedRootType,
baseAnnotation.Segment.StartPath,
m.Type);
}
return result;
}
/// <summary>
/// Rebinds the specified <paramref name="init"/> expression by gathering
/// annotated paths and returning an expression that calls the
/// ProjectionGetEntity method.
/// </summary>
/// <param name="init">Member initialization expression.</param>
/// <returns>A new expression suitable for materialization.</returns>
private Expression RebindEntityMemberInit(MemberInitExpression init)
{
Debug.Assert(init != null, "init != null");
Debug.Assert(init.Bindings.Count > 0, "init.Bindings.Count > 0 -- otherwise this is just empty construction");
// We "jump" into entities only if we're not already materializing an entity.
Expression[] expressions;
if (!this.pathBuilder.HasRewrites)
{
MemberAssignmentAnalysis propertyAnalysis = MemberAssignmentAnalysis.Analyze(
this.pathBuilder.LambdaParameterInScope,
((MemberAssignment)init.Bindings[0]).Expression);
expressions = propertyAnalysis.GetExpressionsToTargetEntity();
Debug.Assert(expressions.Length != 0, "expressions.Length != 0 -- otherwise there is no correlation to parameter in entity member init");
}
else
{
expressions = MemberAssignmentAnalysis.EmptyExpressionArray;
}
Expression entryParameterAtMemberInit = this.pathBuilder.ParameterEntryInScope;
List<string> propertyNames = new List<string>();
List<Func<object, object, Type, object>> propertyFunctions = new List<Func<object, object, Type, object>>();
Type projectedType = init.NewExpression.Type;
Expression projectedTypeExpression = Expression.Constant(projectedType, typeof(Type));
// We may need to materialize from deeper in the entity tree for anonymous types.
// t => new { nested = new Nested() { nid = t.nested.nid }
//
// We do the same kind of rewriting we'd do for a nested entity
// but at the initializing scope (rather than at the member assignment scope).
//
// t=> new { nested = ProjInit(GetEntry(entry0, "Nested"), "nid", *->nid) }
Expression entryToInitValue; // Expression that yields value for entry in target tree.
Expression expectedParamValue; // Expression that yield expectedType in target tree.
ParameterExpression entryParameterForMembers; // Parameter expression members think of as "entry".
ParameterExpression expectedParameterForMembers; // Parameter expression members think of as "expectedType" for entry.
string[] expressionNames = expressions.Skip(1).Select(e => ((MemberExpression)e).Member.Name).ToArray();
if (expressions.Length <= 1)
{
entryToInitValue = this.pathBuilder.ParameterEntryInScope;
expectedParamValue = this.pathBuilder.ExpectedParamTypeInScope;
entryParameterForMembers = (ParameterExpression)this.pathBuilder.ParameterEntryInScope;
expectedParameterForMembers = (ParameterExpression)this.pathBuilder.ExpectedParamTypeInScope;
}
else
{
entryToInitValue = this.GetDeepestEntry(expressions);
expectedParamValue = projectedTypeExpression;
entryParameterForMembers = Expression.Parameter(typeof(object), "subentry" + this.identifierId++);
expectedParameterForMembers = (ParameterExpression)this.pathBuilder.ExpectedParamTypeInScope;
// Annotate the entry expression with 'how we get to it' information.
// The annotation on entryToInitiValue is picked up
// The annotation on entryParameterForMembers is picked up to build nested member-init on entities.
ProjectionPath entryPath = new ProjectionPath(
(ParameterExpression)this.pathBuilder.LambdaParameterInScope,
this.pathBuilder.ExpectedParamTypeInScope,
this.pathBuilder.ParameterEntryInScope,
expressions.Skip(1));
this.annotations.Add(entryToInitValue, new ExpressionAnnotation() { Segment = entryPath[entryPath.Count - 1] });
this.annotations.Add(entryParameterForMembers, new ExpressionAnnotation() { Segment = entryPath[entryPath.Count - 1] });
this.pathBuilder.RegisterRewrite(this.pathBuilder.LambdaParameterInScope, expressionNames, entryParameterForMembers);
}
for (int i = 0; i < init.Bindings.Count; i++)
{
MemberAssignment assignment = (MemberAssignment)init.Bindings[i];
string memberName = ClientTypeUtil.GetServerDefinedName(assignment.Member);
propertyNames.Add(memberName);
LambdaExpression propertyLambda;
// Here are the rewrites we do for member inits:
// new T { id = t.id }
// => ProjInit(pt, "id", f(t -> *.id));
//
// new T { t2 = new T2 { id2 = *.t2.id2 } }
// => ProjInit(pt, "t2", f(ProjInit(pt->t2), "id2", *.id2)))
if ((ClientTypeUtil.TypeOrElementTypeIsEntity(ClientTypeUtil.GetMemberType(assignment.Member)) &&
assignment.Expression.NodeType == ExpressionType.MemberInit))
{
Expression nestedEntry = CallMaterializer(
"ProjectionGetEntry",
entryParameterAtMemberInit,
Expression.Constant(assignment.Member.Name, typeof(string)));
ParameterExpression nestedEntryParameter = Expression.Parameter(
typeof(object),
"subentry" + this.identifierId++);
// Register the rewrite from the top to the entry if necessary.
ProjectionPath entryPath;
ExpressionAnnotation entryAnnotation;
if (this.annotations.TryGetValue(this.pathBuilder.ParameterEntryInScope, out entryAnnotation))
{
entryPath = new ProjectionPath(
(ParameterExpression)this.pathBuilder.LambdaParameterInScope,
this.pathBuilder.ExpectedParamTypeInScope,
entryParameterAtMemberInit);
entryPath.AddRange(entryAnnotation.Segment.StartPath);
}
else
{
entryPath = new ProjectionPath(
(ParameterExpression)this.pathBuilder.LambdaParameterInScope,
this.pathBuilder.ExpectedParamTypeInScope,
entryParameterAtMemberInit,
expressions.Skip(1));
}
#if DNXCORE50
Type memberParentType = assignment.Member.DeclaringType;
#else
Type memberParentType = assignment.Member.ReflectedType;
#endif
ProjectionPathSegment nestedSegment = new ProjectionPathSegment(
entryPath,
assignment.Member.Name,
memberParentType);
entryPath.Add(nestedSegment);
string[] names = (entryPath.Where(m => m.Member != null).Select(m => m.Member)).ToArray();
this.annotations.Add(nestedEntryParameter, new ExpressionAnnotation() { Segment = nestedSegment });
this.pathBuilder.RegisterRewrite(this.pathBuilder.LambdaParameterInScope, names, nestedEntryParameter);
Expression e = this.Visit(assignment.Expression);
this.pathBuilder.RevokeRewrite(this.pathBuilder.LambdaParameterInScope, names);
this.annotations.Remove(nestedEntryParameter);
e = Expression.Convert(e, typeof(object));
ParameterExpression[] parameters =
new ParameterExpression[]
{
this.materializerExpression,
nestedEntryParameter,
expectedParameterForMembers,
};
propertyLambda = Expression.Lambda(e, parameters);
Expression[] nestedParams =
new Expression[]
{
this.materializerExpression,
nestedEntry,
expectedParameterForMembers,
};
var invokeParameters =
new ParameterExpression[]
{
this.materializerExpression,
(ParameterExpression)entryParameterAtMemberInit,
expectedParameterForMembers,
};
propertyLambda = Expression.Lambda(Expression.Invoke(propertyLambda, nestedParams), invokeParameters);
}
else
{
// We need an expression of object, which might require boxing.
Expression e = this.Visit(assignment.Expression);
e = Expression.Convert(e, typeof(object));
ParameterExpression[] parameters =
new ParameterExpression[]
{
this.materializerExpression,
entryParameterForMembers,
expectedParameterForMembers,
};
propertyLambda = Expression.Lambda(e, parameters);
}
#if TRACE_CLIENT_PROJECTIONS
Trace.WriteLine("Compiling lambda for " + assignment.Member.Name + ": " + propertyLambda);
#endif
propertyFunctions.Add((Func<object, object, Type, object>)propertyLambda.Compile());
}
// Revoke rewrites used for nested initialization.
for (int i = 1; i < expressions.Length; i++)
{
this.pathBuilder.RevokeRewrite(this.pathBuilder.LambdaParameterInScope, expressionNames);
this.annotations.Remove(entryToInitValue);
this.annotations.Remove(entryParameterForMembers);
}
Expression reboundExpression = CallMaterializer(
"ProjectionInitializeEntity",
this.materializerExpression,
entryToInitValue,
expectedParamValue,
projectedTypeExpression,
Expression.Constant(propertyNames.ToArray()),
Expression.Constant(propertyFunctions.ToArray()));
return Expression.Convert(reboundExpression, projectedType);
}
/// <summary>Rebinds the specified parameter expression as a path-based access.</summary>
/// <param name="expression">Expression to rebind.</param>
/// <param name='annotation'>Annotation for the expression to rebind.</param>
/// <returns>The rebound expression.</returns>
private Expression RebindParameter(Expression expression, ExpressionAnnotation annotation)
{
Debug.Assert(expression != null, "expression != null");
Debug.Assert(annotation != null, "annotation != null");
Expression result;
result = this.CallValueForPathWithType(
annotation.Segment.StartPath.RootEntry,
annotation.Segment.StartPath.ExpectedRootType,
annotation.Segment.StartPath,
expression.Type);
// Refresh the annotation so the next one that comes along
// doesn't start off with an already-written path.
ProjectionPath parameterPath = new ProjectionPath(
annotation.Segment.StartPath.Root,
annotation.Segment.StartPath.ExpectedRootType,
annotation.Segment.StartPath.RootEntry);
ProjectionPathSegment parameterSegment = new ProjectionPathSegment(parameterPath, null, null);
parameterPath.Add(parameterSegment);
this.annotations[expression] = new ExpressionAnnotation() { Segment = parameterSegment };
return result;
}
/// <summary>LambdaExpression visit method.</summary>
/// <param name="lambda">The LambdaExpression to visit</param>
/// <returns>The visited LambdaExpression</returns>
internal override Expression VisitLambda(LambdaExpression lambda)
{
Debug.Assert(lambda != null, "lambda != null");
Expression result;
if (!this.topLevelProjectionFound || lambda.Parameters.Count == 1 && ClientTypeUtil.TypeOrElementTypeIsEntity(lambda.Parameters[0].Type))
{
this.topLevelProjectionFound = true;
ParameterExpression expectedTypeParameter = Expression.Parameter(typeof(Type), "type" + this.identifierId);
ParameterExpression entryParameter = Expression.Parameter(typeof(object), "entry" + this.identifierId);
this.identifierId++;
this.pathBuilder.EnterLambdaScope(lambda, entryParameter, expectedTypeParameter);
ProjectionPath parameterPath = new ProjectionPath(lambda.Parameters[0], expectedTypeParameter, entryParameter);
ProjectionPathSegment parameterSegment = new ProjectionPathSegment(parameterPath, null, null);
parameterPath.Add(parameterSegment);
this.annotations[lambda.Parameters[0]] = new ExpressionAnnotation() { Segment = parameterSegment };
Expression body = this.Visit(lambda.Body);
// Value types must be boxed explicitly; the lambda initialization
// won't do it for us (type-compatible types still work, so all
// references will work fine with System.Object).
if (body.Type.IsValueType())
{
body = Expression.Convert(body, typeof(object));
}
result = Expression.Lambda<Func<object, object, Type, object>>(
body,
this.materializerExpression,
entryParameter,
expectedTypeParameter);
this.pathBuilder.LeaveLambdaScope();
}
else
{
result = base.VisitLambda(lambda);
}
return result;
}
