/// <summary> /// If there is a MemberInitExpression 'new Person { ID = p.ID, Friend = new Person { ID = p.Friend.ID }}' /// or a NewExpression 'new { ID = p.ID, Friend = new { ID = p.Friend.ID }}', /// this method validates against the RHS of the member assigment, the expression "p.ID" for example. /// </summary> /// <param name="expressionToAssign">The expression to validate.</param> /// <param name="initType">Type of the MemberInit or the New expression.</param> /// <param name="previousNested">The outter nested initializer of the current initializer we are checking.</param> /// <returns>true if the expression to assign is fine; false otherwise.</returns> private bool CheckCompatibleAssigmentExpression(Expression expressionToAssign, Type initType, ref MemberAssignmentAnalysis previousNested) { MemberAssignmentAnalysis nested = MemberAssignmentAnalysis.Analyze(this.entity, expressionToAssign); if (nested.MultiplePathsFound) { this.multiplePathsFound = true; return(false); } // When we're visitng a nested entity initializer, we're exactly one level above that. Exception incompatibleException = nested.CheckCompatibleAssignments(initType, ref previousNested); if (incompatibleException != null) { this.incompatibleAssignmentsException = incompatibleException; return(false); } if (this.pathFromEntity.Count == 0) { this.pathFromEntity.AddRange(nested.GetExpressionsToTargetEntity()); } return(true); }
internal static MemberAssignmentAnalysis Analyze(Expression entityInScope, Expression assignmentExpression) { MemberAssignmentAnalysis analysis = new MemberAssignmentAnalysis(entityInScope); analysis.Visit(assignmentExpression); return(analysis); }
internal override Expression VisitMemberInit(MemberInitExpression init) { Expression result = init; MemberAssignmentAnalysis previousNested = null; foreach (var binding in init.Bindings) { MemberAssignment assignment = binding as MemberAssignment; if (assignment == null) { continue; } MemberAssignmentAnalysis nested = MemberAssignmentAnalysis.Analyze(this.entity, assignment.Expression); if (nested.MultiplePathsFound) { this.multiplePathsFound = true; break; } Exception incompatibleException = nested.CheckCompatibleAssignments(init.Type, ref previousNested); if (incompatibleException != null) { this.incompatibleAssignmentsException = incompatibleException; break; } if (this.pathFromEntity.Count == 0) { this.pathFromEntity.AddRange(nested.GetExpressionsToTargetEntity()); } } return(result); }
internal static MemberAssignmentAnalysis Analyze(Expression entityInScope, Expression assignmentExpression) { Debug.Assert(entityInScope != null, "entityInScope != null"); Debug.Assert(assignmentExpression != null, "assignmentExpression != null"); MemberAssignmentAnalysis result = new MemberAssignmentAnalysis(entityInScope); result.Visit(assignmentExpression); return result; }
internal static MemberAssignmentAnalysis Analyze(Expression entityInScope, Expression assignmentExpression) { Debug.Assert(entityInScope != null, "entityInScope != null"); Debug.Assert(assignmentExpression != null, "assignmentExpression != null"); MemberAssignmentAnalysis result = new MemberAssignmentAnalysis(entityInScope); result.Visit(assignmentExpression); return(result); }
internal Exception CheckCompatibleAssignments(Type targetType, ref MemberAssignmentAnalysis previous) { if (previous == null) { previous = this; return null; } Expression[] expressionsToTargetEntity = previous.GetExpressionsToTargetEntity(); Expression[] candidate = this.GetExpressionsToTargetEntity(); return CheckCompatibleAssignments(targetType, expressionsToTargetEntity, candidate); }
internal Exception CheckCompatibleAssignments(Type targetType, ref MemberAssignmentAnalysis previous) { if (previous == null) { previous = this; return(null); } Expression[] expressionsToTargetEntity = previous.GetExpressionsToTargetEntity(); Expression[] candidate = this.GetExpressionsToTargetEntity(); return(CheckCompatibleAssignments(targetType, expressionsToTargetEntity, candidate)); }
internal static void Analyze(MemberInitExpression mie, PathBox pb) { Debug.Assert(mie != null, "mie != null"); var epa = new EntityProjectionAnalyzer(pb, mie.Type); MemberAssignmentAnalysis targetEntityPath = null; foreach (MemberBinding mb in mie.Bindings) { MemberAssignment ma = mb as MemberAssignment; epa.Visit(ma.Expression); if (ma != null) { var analysis = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, ma.Expression); if (analysis.IncompatibleAssignmentsException != null) { throw analysis.IncompatibleAssignmentsException; } Type targetType = GetMemberType(ma.Member); Expression[] lastExpressions = analysis.GetExpressionsBeyondTargetEntity(); if (lastExpressions.Length == 0) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(targetType, ma.Expression)); } MemberExpression lastExpression = lastExpressions[lastExpressions.Length - 1] as MemberExpression; Debug.Assert( !analysis.MultiplePathsFound, "!analysis.MultiplePathsFound -- the initilizer has been visited, and cannot be empty, and expressions that can combine paths should have thrown exception during initializer analysis"); Debug.Assert( lastExpression != null, "lastExpression != null -- the initilizer has been visited, and cannot be empty, and the only expressions that are allowed can be formed off the parameter, so this is always correlatd"); if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name)) { throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name)); } analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath); bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType); bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type); if (sourceIsEntity && !targetIsEntity) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression)); } } } }
internal override Expression VisitMemberInit(MemberInitExpression init) { Expression expression = init; MemberAssignmentAnalysis previousNested = null; foreach (MemberBinding binding in init.Bindings) { MemberAssignment assignment = binding as MemberAssignment; if ((assignment != null) && !this.CheckCompatibleAssigmentExpression(assignment.Expression, init.Type, ref previousNested)) { return(expression); } } return(expression); }
internal override NewExpression VisitNew(NewExpression nex) { if (nex.Members == null) { return(base.VisitNew(nex)); } MemberAssignmentAnalysis previousNested = null; foreach (Expression expression in nex.Arguments) { if (!this.CheckCompatibleAssigmentExpression(expression, nex.Type, ref previousNested)) { return(nex); } } return(nex); }
private bool CheckCompatibleAssigmentExpression(Expression expressionToAssign, Type initType, ref MemberAssignmentAnalysis previousNested) { MemberAssignmentAnalysis analysis = Analyze(this.entity, expressionToAssign); if (analysis.MultiplePathsFound) { this.multiplePathsFound = true; return false; } Exception exception = analysis.CheckCompatibleAssignments(initType, ref previousNested); if (exception != null) { this.incompatibleAssignmentsException = exception; return false; } if (this.pathFromEntity.Count == 0) { this.pathFromEntity.AddRange(analysis.GetExpressionsToTargetEntity()); } return true; }
/// <summary>Visits a nested member init.</summary> /// <param name="init">Expression to visit.</param> /// <returns>The same expression.</returns> internal override Expression VisitMemberInit(MemberInitExpression init) { Expression result = init; MemberAssignmentAnalysis previousNested = null; foreach (var binding in init.Bindings) { MemberAssignment assignment = binding as MemberAssignment; if (assignment == null) { continue; } if (!this.CheckCompatibleAssigmentExpression(assignment.Expression, init.Type, ref previousNested)) { break; } } return(result); }
/// <summary> /// NewExpression visit method /// </summary> /// <param name="nex">The NewExpression to visit</param> /// <returns>The visited NewExpression</returns> internal override NewExpression VisitNew(NewExpression nex) { if (nex.Members == null) { return(base.VisitNew(nex)); } else { // Member init for an anonymous type. MemberAssignmentAnalysis previousNested = null; foreach (var arg in nex.Arguments) { if (!this.CheckCompatibleAssigmentExpression(arg, nex.Type, ref previousNested)) { break; } } return(nex); } }
internal static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context) { ProjectionAnalyzer.EntityProjectionAnalyzer analyzer = new ProjectionAnalyzer.EntityProjectionAnalyzer(pb, mie.Type, context); MemberAssignmentAnalysis previous = null; foreach (MemberBinding binding in mie.Bindings) { MemberAssignment assignment = binding as MemberAssignment; analyzer.Visit(assignment.Expression); if (assignment != null) { MemberAssignmentAnalysis analysis2 = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, assignment.Expression); if (analysis2.IncompatibleAssignmentsException != null) { throw analysis2.IncompatibleAssignmentsException; } Type memberType = ClientTypeUtil.GetMemberType(assignment.Member); Expression[] expressionsBeyondTargetEntity = analysis2.GetExpressionsBeyondTargetEntity(); if (expressionsBeyondTargetEntity.Length == 0) { throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(memberType, assignment.Expression)); } MemberExpression expression = expressionsBeyondTargetEntity[expressionsBeyondTargetEntity.Length - 1] as MemberExpression; analysis2.CheckCompatibleAssignments(mie.Type, ref previous); if (expression != null) { if (expression.Member.Name != assignment.Member.Name) { throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_PropertyNamesMustMatchInProjections(expression.Member.Name, assignment.Member.Name)); } bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(memberType); if (ClientTypeUtil.TypeOrElementTypeIsEntity(expression.Type) && !flag) { throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjection(memberType, assignment.Expression)); } } } } }
private bool CheckCompatibleAssigmentExpression(Expression expressionToAssign, Type initType, ref MemberAssignmentAnalysis previousNested) { MemberAssignmentAnalysis analysis = Analyze(this.entity, expressionToAssign); if (analysis.MultiplePathsFound) { this.multiplePathsFound = true; return(false); } Exception exception = analysis.CheckCompatibleAssignments(initType, ref previousNested); if (exception != null) { this.incompatibleAssignmentsException = exception; return(false); } if (this.pathFromEntity.Count == 0) { this.pathFromEntity.AddRange(analysis.GetExpressionsToTargetEntity()); } return(true); }
internal static MemberAssignmentAnalysis Analyze(Expression entityInScope, Expression assignmentExpression) { MemberAssignmentAnalysis analysis = new MemberAssignmentAnalysis(entityInScope); analysis.Visit(assignmentExpression); return analysis; }
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"); 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)); Expression entryToInitValue; Expression expectedParamValue; ParameterExpression entryParameterForMembers; ParameterExpression expectedParameterForMembers; 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; 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]; propertyNames.Add(assignment.Member.Name); LambdaExpression propertyLambda; if ((ClientType.CheckElementTypeIsEntity(assignment.Member.ReflectedType) && 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++); 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)); } ProjectionPathSegment nestedSegment = new ProjectionPathSegment( entryPath, assignment.Member.Name, assignment.Member.ReflectedType); 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 { 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()); } 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)); }
private Expression RebindEntityMemberInit(MemberInitExpression init) { Expression[] expressionsToTargetEntity; Expression deepestEntry; Expression expectedParamTypeInScope; ParameterExpression expression5; ParameterExpression expression6; if (!this.pathBuilder.HasRewrites) { expressionsToTargetEntity = MemberAssignmentAnalysis.Analyze(this.pathBuilder.LambdaParameterInScope, ((MemberAssignment)init.Bindings[0]).Expression).GetExpressionsToTargetEntity(); } else { expressionsToTargetEntity = MemberAssignmentAnalysis.EmptyExpressionArray; } Expression parameterEntryInScope = this.pathBuilder.ParameterEntryInScope; List <string> list = new List <string>(); List <Func <object, object, Type, object> > list2 = new List <Func <object, object, Type, object> >(); Type type = init.NewExpression.Type; Expression expression2 = Expression.Constant(type, typeof(Type)); string[] names = (from e in expressionsToTargetEntity.Skip <Expression>(1) select((MemberExpression)e).Member.Name).ToArray <string>(); if (expressionsToTargetEntity.Length <= 1) { deepestEntry = this.pathBuilder.ParameterEntryInScope; expectedParamTypeInScope = this.pathBuilder.ExpectedParamTypeInScope; expression5 = (ParameterExpression)this.pathBuilder.ParameterEntryInScope; expression6 = (ParameterExpression)this.pathBuilder.ExpectedParamTypeInScope; } else { deepestEntry = this.GetDeepestEntry(expressionsToTargetEntity); expectedParamTypeInScope = expression2; expression5 = Expression.Parameter(typeof(object), "subentry" + this.identifierId++); expression6 = (ParameterExpression)this.pathBuilder.ExpectedParamTypeInScope; ProjectionPath path = new ProjectionPath((ParameterExpression)this.pathBuilder.LambdaParameterInScope, this.pathBuilder.ExpectedParamTypeInScope, this.pathBuilder.ParameterEntryInScope, expressionsToTargetEntity.Skip <Expression>(1)); ExpressionAnnotation annotation = new ExpressionAnnotation { Segment = path[path.Count - 1] }; this.annotations.Add(deepestEntry, annotation); ExpressionAnnotation annotation2 = new ExpressionAnnotation { Segment = path[path.Count - 1] }; this.annotations.Add(expression5, annotation2); this.pathBuilder.RegisterRewrite(this.pathBuilder.LambdaParameterInScope, names, expression5); } for (int i = 0; i < init.Bindings.Count; i++) { LambdaExpression expression7; MemberAssignment assignment = (MemberAssignment)init.Bindings[i]; list.Add(assignment.Member.Name); if (ClientTypeUtil.TypeOrElementTypeIsEntity(ClientTypeUtil.GetMemberType(assignment.Member)) && (assignment.Expression.NodeType == ExpressionType.MemberInit)) { ProjectionPath path2; ExpressionAnnotation annotation3; Expression expression8 = CallMaterializer("ProjectionGetEntry", new Expression[] { parameterEntryInScope, Expression.Constant(assignment.Member.Name, typeof(string)) }); ParameterExpression key = Expression.Parameter(typeof(object), "subentry" + this.identifierId++); if (this.annotations.TryGetValue(this.pathBuilder.ParameterEntryInScope, out annotation3)) { path2 = new ProjectionPath((ParameterExpression)this.pathBuilder.LambdaParameterInScope, this.pathBuilder.ExpectedParamTypeInScope, parameterEntryInScope); path2.AddRange(annotation3.Segment.StartPath); } else { path2 = new ProjectionPath((ParameterExpression)this.pathBuilder.LambdaParameterInScope, this.pathBuilder.ExpectedParamTypeInScope, parameterEntryInScope, expressionsToTargetEntity.Skip <Expression>(1)); } Type reflectedType = assignment.Member.ReflectedType; ProjectionPathSegment item = new ProjectionPathSegment(path2, assignment.Member.Name, reflectedType); path2.Add(item); string[] strArray2 = (from m in path2 where m.Member != null select m.Member).ToArray <string>(); ExpressionAnnotation annotation4 = new ExpressionAnnotation { Segment = item }; this.annotations.Add(key, annotation4); this.pathBuilder.RegisterRewrite(this.pathBuilder.LambdaParameterInScope, strArray2, key); Expression expression = this.Visit(assignment.Expression); this.pathBuilder.RevokeRewrite(this.pathBuilder.LambdaParameterInScope, strArray2); this.annotations.Remove(key); expression = Expression.Convert(expression, typeof(object)); ParameterExpression[] parameters = new ParameterExpression[] { this.materializerExpression, key, expression6 }; expression7 = Expression.Lambda(expression, parameters); Expression[] arguments = new Expression[] { this.materializerExpression, expression8, expression6 }; ParameterExpression[] expressionArray4 = new ParameterExpression[] { this.materializerExpression, (ParameterExpression)parameterEntryInScope, expression6 }; expression7 = Expression.Lambda(Expression.Invoke(expression7, arguments), expressionArray4); } else { Expression body = Expression.Convert(this.Visit(assignment.Expression), typeof(object)); ParameterExpression[] expressionArray5 = new ParameterExpression[] { this.materializerExpression, expression5, expression6 }; expression7 = Expression.Lambda(body, expressionArray5); } list2.Add((Func <object, object, Type, object>)expression7.Compile()); } for (int j = 1; j < expressionsToTargetEntity.Length; j++) { this.pathBuilder.RevokeRewrite(this.pathBuilder.LambdaParameterInScope, names); this.annotations.Remove(deepestEntry); this.annotations.Remove(expression5); } return(Expression.Convert(CallMaterializer("ProjectionInitializeEntity", new Expression[] { this.materializerExpression, deepestEntry, expectedParamTypeInScope, expression2, Expression.Constant(list.ToArray()), Expression.Constant(list2.ToArray()) }), type)); }
/// <summary>Analyzes the specified member-init expression.</summary> /// <param name="mie">Expression to analyze.</param> /// <param name="pb">Path-tracking object to store analysis in.</param> internal static void Analyze(MemberInitExpression mie, PathBox pb) { Debug.Assert(mie != null, "mie != null"); var epa = new EntityProjectionAnalyzer(pb, mie.Type); MemberAssignmentAnalysis targetEntityPath = null; foreach (MemberBinding mb in mie.Bindings) { MemberAssignment ma = mb as MemberAssignment; epa.Visit(ma.Expression); if (ma != null) { var analysis = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, ma.Expression); if (analysis.IncompatibleAssignmentsException != null) { throw analysis.IncompatibleAssignmentsException; } // Note that an "empty" assignment on the binding is not checked/handled, // because the funcletizer would have turned that into a constant // in the tree, the visit earlier in this method would have thrown // an exception at finding a constant in an entity projection. // // We do account however for failing to find a reference off the // parameter entry to detect errors like this: new ET() { Ref = e } // Here it looks like the new ET should be the parent of 'e', but // there is nothing in scope that represents that. // // This also explains while error messages might be a bit misleading // in this case (because they reference a constant when the user // hasn't included any). Type targetType = GetMemberType(ma.Member); Expression[] lastExpressions = analysis.GetExpressionsBeyondTargetEntity(); if (lastExpressions.Length == 0) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(targetType, ma.Expression)); } MemberExpression lastExpression = lastExpressions[lastExpressions.Length - 1] as MemberExpression; Debug.Assert( !analysis.MultiplePathsFound, "!analysis.MultiplePathsFound -- the initilizer has been visited, and cannot be empty, and expressions that can combine paths should have thrown exception during initializer analysis"); Debug.Assert( lastExpression != null, "lastExpression != null -- the initilizer has been visited, and cannot be empty, and the only expressions that are allowed can be formed off the parameter, so this is always correlatd"); if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name)) { throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name)); } analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath); // Unless we're initializing an entity, we should not traverse into the parameter in scope. bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType); bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type); if (sourceIsEntity && !targetIsEntity) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression)); } } } }