internal override Expression VisitMemberAccess(MemberExpression m)
{
Debug.Assert(m != null, "m != null");
if (ClientConvert.IsKnownNullableType(m.Expression.Type))
{
return(base.VisitMemberAccess(m));
}
if (!CommonUtil.IsClientType(m.Expression.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, m.ToString()));
}
PropertyInfo pi = null;
if (ResourceBinder.PatternRules.MatchNonPrivateReadableProperty(m, out pi))
{
Expression e = base.VisitMemberAccess(m);
this.box.AppendToPath(pi);
return(e);
}
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, m.ToString()));
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = CommonUtil.IsClientType(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(SR.ALinqCannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(SR.ALinqCannotCreateConstantEntity);
default:
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
internal override Expression VisitConstant(ConstantExpression c)
{
if (CommonUtil.IsClientType(c.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, c.ToString()));
}
return(base.VisitConstant(c));
}
internal override NewExpression VisitNew(NewExpression nex)
{
if (CommonUtil.IsClientType(nex.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, nex.ToString()));
}
return(base.VisitNew(nex));
}
internal override Expression VisitTypeIs(TypeBinaryExpression b)
{
if (CommonUtil.IsClientType(b.Expression.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, b.ToString()));
}
return(base.VisitTypeIs(b));
}
internal override Expression VisitInvocation(InvocationExpression iv)
{
if (CommonUtil.IsClientType(iv.Expression.Type) ||
iv.Arguments.Any(a => CommonUtil.IsClientType(a.Type)))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, iv.ToString()));
}
return(base.VisitInvocation(iv));
}
internal override Expression VisitUnary(UnaryExpression u)
{
Debug.Assert(u != null, "u != null");
if (!ResourceBinder.PatternRules.MatchConvertToAssignable(u))
{
if (CommonUtil.IsClientType(u.Operand.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, u.ToString()));
}
}
return(base.VisitUnary(u));
}
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(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjectionToEntity, 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(string.Format(CultureInfo.CurrentCulture, SR.ALinqPropertyNamesMustMatchInProjections, lastExpression.Member.Name, ma.Member.Name));
}
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
bool targetIsEntity = CommonUtil.IsClientType(targetType);
bool sourceIsEntity = CommonUtil.IsClientType(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, targetType, ma.Expression));
}
}
}
}
private static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
Debug.Assert(pb != null, "pb != null");
bool knownEntityType = CommonUtil.IsClientType(mie.Type);
if (knownEntityType)
{
EntityProjectionAnalyzer.Analyze(mie, pb);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb);
}
}
internal override Expression VisitMethodCall(MethodCallExpression m)
{
if (ProjectionAnalyzer.IsMethodCallAllowedEntitySequence(m))
{
ProjectionAnalyzer.CheckChainedSequence(m, this.type);
return(base.VisitMethodCall(m));
}
if ((m.Object != null ? CommonUtil.IsClientType(m.Object.Type) : false) ||
m.Arguments.Any(a => CommonUtil.IsClientType(a.Type)))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, m.ToString()));
}
return(base.VisitMethodCall(m));
}
internal override Expression VisitConditional(ConditionalExpression c)
{
var nullCheck = ResourceBinder.PatternRules.MatchNullCheck(this.box.ParamExpressionInScope, c);
if (nullCheck.Match)
{
this.Visit(nullCheck.AssignExpression);
return(c);
}
if (CommonUtil.IsClientType(c.Test.Type) || CommonUtil.IsClientType(c.IfTrue.Type) || CommonUtil.IsClientType(c.IfFalse.Type))
{
throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjection, this.type, c.ToString()));
}
return(base.VisitConditional(c));
}
internal static bool Analyze(LambdaExpression le, ResourceExpression re, bool matchMembers)
{
Debug.Assert(le != null, "le != null");
if (le.Body.NodeType == ExpressionType.Constant)
{
if (CommonUtil.IsClientType(le.Body.Type))
{
throw new NotSupportedException(SR.ALinqCannotCreateConstantEntity);
}
re.Projection = new ProjectionQueryOptionExpression(le.Body.Type, le, new List <string>());
return(true);
}
if (le.Body.NodeType == ExpressionType.Call)
{
MethodCallExpression mce = le.Body as MethodCallExpression;
if (mce.Method == ReflectionUtil.ProjectMethodInfo.MakeGenericMethod(le.Body.Type))
{
ConstantExpression paths = mce.Arguments[1] as ConstantExpression;
re.Projection = new ProjectionQueryOptionExpression(le.Body.Type, ProjectionQueryOptionExpression.DefaultLambda, new List <string>((string[])paths.Value));
return(true);
}
}
if (le.Body.NodeType == ExpressionType.MemberInit || le.Body.NodeType == ExpressionType.New)
{
AnalyzeResourceExpression(le, re);
return(true);
}
if (matchMembers)
{
Expression withoutConverts = SkipConverts(le.Body);
if (withoutConverts.NodeType == ExpressionType.MemberAccess)
{
AnalyzeResourceExpression(le, re);
return(true);
}
}
return(false);
}
internal void AppendToPath(PropertyInfo pi)
{
Debug.Assert(pi != null, "pi != null");
StringBuilder sb;
Type t = TypeSystem.GetElementType(pi.PropertyType);
if (CommonUtil.IsClientType(t))
{
sb = this.expandPaths.Last();
// Debug.Assert(sb != null);
if (sb.Length > 0)
{
sb.Append(UriHelper.FORWARDSLASH);
}
sb.Append(pi.Name);
}
sb = this.projectionPaths.Last();
Debug.Assert(sb != null, "sb != null -- we are always building paths in the context of a parameter");
RemoveEntireEntityMarkerIfPresent(sb);
if (sb.Length > 0)
{
sb.Append(UriHelper.FORWARDSLASH);
}
sb.Append(pi.Name);
if (CommonUtil.IsClientType(t))
{
AddEntireEntityMarker(sb);
}
}