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