/// <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; }