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