private HqlTreeNode VisitTypeBinaryExpression(TypeBinaryExpression expression) { return(BuildOfType(expression.Expression, expression.TypeOperand)); }
protected override Expression VisitTypeBinary(TypeBinaryExpression node) { this.expressions.Add(node); return(base.VisitTypeBinary(node)); }
protected override Expression VisitTypeIs(TypeBinaryExpression expression) { this.hashCode ^= expression.TypeOperand.GetHashCode(); return(base.VisitTypeIs(expression)); }
/// <summary> /// Creates a <see cref="TypeBinaryExpression"/>. /// </summary> /// <param name="expression"><see cref="TypeBinaryExpression"/> to visit.</param> /// <returns>Returns a <see cref="TypeBinaryExpression"/>.</returns> /// <seealso cref="ExpressionVisitor.VisitTypeBinaryExpression"/> protected override object VisitTypeBinaryExpression(TypeBinaryExpression expression) { return(Expression.TypeIs(VisitExpression(expression.Expression), expression.TypeOperand)); }
private int VisitTypeIs(TypeBinaryExpression tb) { return(CalculateHashCode(tb.Expression) ^ tb.TypeOperand.GetHashCode()); }
protected override Expression MakeTypeBinary(TypeBinaryExpression node, Expression expression) => throw new NotImplementedException();
// TypeBinaryExpression protected internal virtual bool Walk(TypeBinaryExpression node) { return true; }
private Expression Rewrite(Expression expression, ReadOnlyCollection <ParameterExpression> lambdaParameters) { Func <Expression, Expression> selector = null; Func <ElementInit, ElementInit> func2 = null; Func <MemberBinding, MemberBinding> func3 = null; Func <Expression, Expression> func4 = null; Func <Expression, Expression> func5 = null; Func <Expression, Expression> func6 = null; Func <Expression, Expression> func7 = null; Func <Expression, Expression> func8 = null; if (expression == null) { return(null); } switch (expression.NodeType) { case ExpressionType.Add: case ExpressionType.AddChecked: case ExpressionType.And: case ExpressionType.AndAlso: case ExpressionType.Coalesce: case ExpressionType.Divide: case ExpressionType.Equal: case ExpressionType.ExclusiveOr: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LeftShift: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.Modulo: case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: case ExpressionType.NotEqual: case ExpressionType.Or: case ExpressionType.OrElse: case ExpressionType.Power: case ExpressionType.RightShift: case ExpressionType.Subtract: case ExpressionType.SubtractChecked: { BinaryExpression expression2 = (BinaryExpression)expression; return(Expression.MakeBinary(expression2.NodeType, this.Rewrite(expression2.Left, lambdaParameters), this.Rewrite(expression2.Right, lambdaParameters), expression2.IsLiftedToNull, expression2.Method, (LambdaExpression)this.Rewrite(expression2.Conversion, lambdaParameters))); } case ExpressionType.ArrayLength: case ExpressionType.Convert: case ExpressionType.ConvertChecked: case ExpressionType.Negate: case ExpressionType.NegateChecked: case ExpressionType.Not: case ExpressionType.Quote: case ExpressionType.TypeAs: { UnaryExpression expression17 = (UnaryExpression)expression; return(Expression.MakeUnary(expression17.NodeType, this.Rewrite(expression17.Operand, lambdaParameters), expression17.Type, expression17.Method)); } case ExpressionType.ArrayIndex: { MethodCallExpression expression10 = expression as MethodCallExpression; if (expression10 == null) { BinaryExpression expression11 = (BinaryExpression)expression; return(Expression.ArrayIndex(this.Rewrite(expression11.Left, lambdaParameters), this.Rewrite(expression11.Right, lambdaParameters))); } if (func4 == null) { func4 = a => this.Rewrite(a, lambdaParameters); } return(Expression.ArrayIndex(this.Rewrite(expression10.Object, lambdaParameters), expression10.Arguments.Select <Expression, Expression>(func4))); } case ExpressionType.Call: { MethodCallExpression expression12 = (MethodCallExpression)expression; if (func5 == null) { func5 = a => this.Rewrite(a, lambdaParameters); } return(Expression.Call(this.Rewrite(expression12.Object, lambdaParameters), expression12.Method, expression12.Arguments.Select <Expression, Expression>(func5))); } case ExpressionType.Conditional: { ConditionalExpression expression3 = (ConditionalExpression)expression; return(Expression.Condition(this.Rewrite(expression3.Test, lambdaParameters), this.Rewrite(expression3.IfTrue, lambdaParameters), this.Rewrite(expression3.IfFalse, lambdaParameters))); } case ExpressionType.Constant: return(expression); case ExpressionType.Invoke: { InvocationExpression expression4 = (InvocationExpression)expression; if (selector == null) { selector = a => this.Rewrite(a, lambdaParameters); } return(Expression.Invoke(this.Rewrite(expression4.Expression, lambdaParameters), expression4.Arguments.Select <Expression, Expression>(selector))); } case ExpressionType.Lambda: { LambdaExpression expression5 = (LambdaExpression)expression; return(Expression.Lambda(expression5.Type, this.Rewrite(expression5.Body, expression5.Parameters), expression5.Parameters)); } case ExpressionType.ListInit: { ListInitExpression expression6 = (ListInitExpression)expression; if (func2 == null) { func2 = ei => Expression.ElementInit(ei.AddMethod, (IEnumerable <Expression>)(from arg in ei.Arguments select this.Rewrite(arg, lambdaParameters))); } return(Expression.ListInit((NewExpression)this.Rewrite(expression6.NewExpression, lambdaParameters), expression6.Initializers.Select <ElementInit, ElementInit>(func2))); } case ExpressionType.MemberAccess: { MemberExpression expression8 = (MemberExpression)expression; return(Expression.MakeMemberAccess(this.Rewrite(expression8.Expression, lambdaParameters), expression8.Member)); } case ExpressionType.MemberInit: { MemberInitExpression expression9 = (MemberInitExpression)expression; if (func3 == null) { func3 = b => this.Rewrite(b, lambdaParameters); } return(Expression.MemberInit((NewExpression)this.Rewrite(expression9.NewExpression, lambdaParameters), expression9.Bindings.Select <MemberBinding, MemberBinding>(func3))); } case ExpressionType.UnaryPlus: { UnaryExpression expression18 = (UnaryExpression)expression; return(Expression.UnaryPlus(this.Rewrite(expression18.Operand, lambdaParameters), expression18.Method)); } case ExpressionType.New: { NewExpression expression15 = (NewExpression)expression; if (expression15.Constructor != null) { if (func8 == null) { func8 = a => this.Rewrite(a, lambdaParameters); } return(Expression.New(expression15.Constructor, expression15.Arguments.Select <Expression, Expression>(func8))); } return(expression); } case ExpressionType.NewArrayInit: { NewArrayExpression expression13 = (NewArrayExpression)expression; if (func6 == null) { func6 = e => this.Rewrite(e, lambdaParameters); } return(Expression.NewArrayInit(expression13.Type.GetElementType(), expression13.Expressions.Select <Expression, Expression>(func6))); } case ExpressionType.NewArrayBounds: { NewArrayExpression expression14 = (NewArrayExpression)expression; if (func7 == null) { func7 = e => this.Rewrite(e, lambdaParameters); } return(Expression.NewArrayBounds(expression14.Type.GetElementType(), expression14.Expressions.Select <Expression, Expression>(func7))); } case ExpressionType.Parameter: { ParameterExpression expression7 = (ParameterExpression)expression; if ((lambdaParameters == null) || !lambdaParameters.Contains(expression7)) { string name = expression7.Name; for (LocationReferenceEnvironment environment = this.environment; environment != null; environment = environment.Parent) { foreach (LocationReference reference in environment.GetLocationReferences()) { if (string.Equals(reference.Name, name, StringComparison.OrdinalIgnoreCase)) { LocationReference reference3; LocationReference locationReference = reference; if (this.metadata.HasValue && this.metadata.Value.TryGetInlinedLocationReference(reference, out reference3)) { locationReference = reference3; } return(ExpressionUtilities.CreateIdentifierExpression(locationReference)); } } } return(expression7); } return(expression7); } case ExpressionType.TypeIs: { TypeBinaryExpression expression16 = (TypeBinaryExpression)expression; return(Expression.TypeIs(this.Rewrite(expression16.Expression, lambdaParameters), expression16.TypeOperand)); } case ExpressionType.Assign: { BinaryExpression expression22 = (BinaryExpression)expression; return(Expression.Assign(this.Rewrite(expression22.Left, lambdaParameters), this.Rewrite(expression22.Right, lambdaParameters))); } case ExpressionType.Block: { BlockExpression expression19 = (BlockExpression)expression; List <ParameterExpression> list = new List <ParameterExpression>(); foreach (ParameterExpression expression20 in expression19.Variables) { list.Add((ParameterExpression)this.Rewrite(expression20, lambdaParameters)); } List <Expression> list2 = new List <Expression>(); foreach (Expression expression21 in expression19.Expressions) { list2.Add(this.Rewrite(expression21, lambdaParameters)); } return(Expression.Block((IEnumerable <ParameterExpression>)list, (IEnumerable <Expression>)list2)); } } return(expression); }
/// <summary> /// Visit a <see cref="TypeBinaryExpression"/>. /// </summary> /// <param name="expression"><see cref="TypeBinaryExpression"/> to visit.</param> /// <returns>Returns the result of the visit.</returns> protected abstract object VisitTypeBinaryExpression(TypeBinaryExpression expression);
private Expression UpdateTypeEqual(TypeBinaryExpression exp, Expression result) { if (exp.Expression != result) { return Expression.TypeEqual(result, exp.TypeOperand); } return exp; }
protected virtual bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b) { return a.TypeOperand == b.TypeOperand && this.Compare(a.Expression, b.Expression); }
protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { Expression expr = this.Visit(b.Expression); return this.UpdateTypeIs(b, expr, b.TypeOperand); }
protected virtual Expression VisitTypeEqual(TypeBinaryExpression exp) { var result = this.Visit(exp.Expression); return UpdateTypeEqual(exp, result); }
protected TypeBinaryExpression UpdateTypeIs(TypeBinaryExpression b, Expression expression, Type typeOperand) { if (expression != b.Expression || typeOperand != b.TypeOperand) { return Expression.TypeIs(expression, typeOperand); } return b; }
protected override Expression VisitTypeBinary(TypeBinaryExpression b) { return(MakeDirtyMeta(b.Type, null, Visit(b.Expression))); }
static void FindTypeReferences(Expression expression, HashSet <Type> typeReferences) { if (expression == null) { return; } switch (expression.NodeType) { case ExpressionType.Add: case ExpressionType.AddChecked: case ExpressionType.And: case ExpressionType.AndAlso: case ExpressionType.Coalesce: case ExpressionType.Divide: case ExpressionType.Equal: case ExpressionType.ExclusiveOr: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LeftShift: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.Modulo: case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: case ExpressionType.NotEqual: case ExpressionType.Or: case ExpressionType.OrElse: case ExpressionType.Power: case ExpressionType.RightShift: case ExpressionType.Subtract: case ExpressionType.SubtractChecked: BinaryExpression binaryExpression = (BinaryExpression)expression; FindTypeReferences(binaryExpression.Left, typeReferences); FindTypeReferences(binaryExpression.Right, typeReferences); return; case ExpressionType.Conditional: ConditionalExpression conditional = (ConditionalExpression)expression; FindTypeReferences(conditional.Test, typeReferences); FindTypeReferences(conditional.IfTrue, typeReferences); FindTypeReferences(conditional.IfFalse, typeReferences); return; case ExpressionType.Constant: ConstantExpression constantExpr = (ConstantExpression)expression; if (constantExpr.Value is Type) { EnsureTypeReferenced((Type)constantExpr.Value, true, typeReferences); } else if (constantExpr.Value != null) { EnsureTypeReferenced(constantExpr.Value.GetType(), true, typeReferences); } return; case ExpressionType.Invoke: InvocationExpression invocation = (InvocationExpression)expression; FindTypeReferences(invocation.Expression, typeReferences); for (int i = 0; i < invocation.Arguments.Count; i++) { FindTypeReferences(invocation.Arguments[i], typeReferences); } return; case ExpressionType.Lambda: LambdaExpression lambda = (LambdaExpression)expression; FindTypeReferences(lambda.Body, typeReferences); for (int i = 0; i < lambda.Parameters.Count; i++) { FindTypeReferences(lambda.Parameters[i], typeReferences); } return; case ExpressionType.ListInit: ListInitExpression listInit = (ListInitExpression)expression; FindTypeReferences(listInit.NewExpression, typeReferences); for (int i = 0; i < listInit.Initializers.Count; i++) { ReadOnlyCollection <Expression> arguments = listInit.Initializers[i].Arguments; for (int argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++) { FindTypeReferences(arguments[argumentIndex], typeReferences); } } return; case ExpressionType.Parameter: ParameterExpression paramExpr = (ParameterExpression)expression; EnsureTypeReferenced(paramExpr.Type, false, typeReferences); return; case ExpressionType.MemberAccess: MemberExpression memberExpression = (MemberExpression)expression; if (memberExpression.Expression == null) { EnsureTypeReferenced(memberExpression.Member.DeclaringType, true, typeReferences); } else { FindTypeReferences(memberExpression.Expression, typeReferences); } EnsureTypeReferenced(memberExpression.Type, false, typeReferences); return; case ExpressionType.MemberInit: MemberInitExpression memberInit = (MemberInitExpression)expression; FindTypeReferences(memberInit.NewExpression, typeReferences); ReadOnlyCollection <MemberBinding> bindings = memberInit.Bindings; for (int i = 0; i < bindings.Count; i++) { FindTypeReferences(bindings[i], typeReferences); } return; case ExpressionType.ArrayIndex: // ArrayIndex can be a MethodCallExpression or a BinaryExpression MethodCallExpression arrayIndex = expression as MethodCallExpression; if (arrayIndex != null) { FindTypeReferences(arrayIndex.Object, typeReferences); ReadOnlyCollection <Expression> arguments = arrayIndex.Arguments; for (int i = 0; i < arguments.Count; i++) { FindTypeReferences(arguments[i], typeReferences); } return; } BinaryExpression alternateIndex = (BinaryExpression)expression; FindTypeReferences(alternateIndex.Left, typeReferences); FindTypeReferences(alternateIndex.Right, typeReferences); return; case ExpressionType.Call: MethodCallExpression methodCall = (MethodCallExpression)expression; MethodInfo method = methodCall.Method; EnsureTypeReferenced(methodCall.Type, false, typeReferences); if (methodCall.Object != null) { FindTypeReferences(methodCall.Object, typeReferences); } else { EnsureTypeReferenced(method.DeclaringType, true, typeReferences); } if (method.IsGenericMethod && !method.IsGenericMethodDefinition && !method.ContainsGenericParameters) { // closed generic method Type[] typeArgs = method.GetGenericArguments(); for (int i = 1; i < typeArgs.Length; ++i) { EnsureTypeReferenced(typeArgs[i], true, typeReferences); } } ParameterInfo[] parameters = method.GetParameters(); if (parameters != null) { foreach (ParameterInfo parameter in parameters) { EnsureTypeReferenced(parameter.ParameterType, false, typeReferences); } } ReadOnlyCollection <Expression> callArguments = methodCall.Arguments; for (int i = 0; i < callArguments.Count; i++) { FindTypeReferences(callArguments[i], typeReferences); } return; case ExpressionType.NewArrayInit: NewArrayExpression newArray = (NewArrayExpression)expression; EnsureTypeReferenced(newArray.Type.GetElementType(), true, typeReferences); ReadOnlyCollection <Expression> expressions = newArray.Expressions; for (int i = 0; i < expressions.Count; i++) { FindTypeReferences(expressions[i], typeReferences); } return; case ExpressionType.NewArrayBounds: NewArrayExpression newArrayBounds = (NewArrayExpression)expression; EnsureTypeReferenced(newArrayBounds.Type.GetElementType(), true, typeReferences); ReadOnlyCollection <Expression> boundExpressions = newArrayBounds.Expressions; for (int i = 0; i < boundExpressions.Count; i++) { FindTypeReferences(boundExpressions[i], typeReferences); } return; case ExpressionType.New: NewExpression newExpression = (NewExpression)expression; if (newExpression.Constructor != null) { EnsureTypeReferenced(newExpression.Constructor.DeclaringType, true, typeReferences); } else { // if no constructors defined (e.g. structs), the simply use the type EnsureTypeReferenced(newExpression.Type, true, typeReferences); } ReadOnlyCollection <Expression> ctorArguments = newExpression.Arguments; for (int i = 0; i < ctorArguments.Count; i++) { FindTypeReferences(ctorArguments[i], typeReferences); } return; case ExpressionType.TypeIs: TypeBinaryExpression typeBinary = (TypeBinaryExpression)expression; FindTypeReferences(typeBinary.Expression, typeReferences); EnsureTypeReferenced(typeBinary.TypeOperand, true, typeReferences); return; case ExpressionType.TypeAs: case ExpressionType.Convert: case ExpressionType.ConvertChecked: UnaryExpression unary = (UnaryExpression)expression; FindTypeReferences(unary.Operand, typeReferences); EnsureTypeReferenced(unary.Type, true, typeReferences); return; case ExpressionType.ArrayLength: case ExpressionType.Negate: case ExpressionType.NegateChecked: case ExpressionType.Not: case ExpressionType.Quote: case ExpressionType.UnaryPlus: UnaryExpression unaryExpression = (UnaryExpression)expression; FindTypeReferences(unaryExpression.Operand, typeReferences); return; // Expression Tree V2.0 types. This is due to the hosted VB compiler generating ET V2.0 nodes case ExpressionType.Block: BlockExpression block = (BlockExpression)expression; ReadOnlyCollection <ParameterExpression> variables = block.Variables; for (int i = 0; i < variables.Count; i++) { FindTypeReferences(variables[i], typeReferences); } ReadOnlyCollection <Expression> blockExpressions = block.Expressions; for (int i = 0; i < blockExpressions.Count; i++) { FindTypeReferences(blockExpressions[i], typeReferences); } return; case ExpressionType.Assign: BinaryExpression assign = (BinaryExpression)expression; FindTypeReferences(assign.Left, typeReferences); FindTypeReferences(assign.Right, typeReferences); return; } Fx.Assert("Don't understand expression type " + expression.NodeType); return; }
private bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b) => a.TypeOperand == b.TypeOperand && Compare(a.Expression, b.Expression);
private HqlTreeNode VisitTypeBinaryExpression(TypeBinaryExpression expression) { return(_hqlTreeBuilder.Equality( _hqlTreeBuilder.Dot(Visit(expression.Expression).AsExpression(), _hqlTreeBuilder.Class()), _hqlTreeBuilder.Ident(expression.TypeOperand.FullName))); }
private static bool Check(TypeBinaryExpression node, object value) { // allow constant TypeIs expressions to be optimized away if (value is bool && ((bool)value) == true) { return node.TypeOperand.IsAssignableFrom(node.Expression.Type); } return false; }
internal override Expression VisitTypeIs(TypeBinaryExpression b) { throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.ALinqExpressionNotSupportedInProjectionToEntity, this.type, b.ToString())); }
protected override Expression VisitTypeIs(TypeBinaryExpression b) { Accumulate(b.TypeOperand); return base.VisitTypeIs(b); }
public virtual EditableTypeBinaryExpression Edit(TypeBinaryExpression expression) { }
//Edited for .NET Core private void Write(Expression exp) { ExpressionType nodeType = exp.NodeType; switch (nodeType) { case ExpressionType.AndAlso: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: break; case ExpressionType.ArrayLength: case ExpressionType.ArrayIndex: case ExpressionType.Coalesce: case ExpressionType.Conditional: case ExpressionType.Divide: case ExpressionType.ExclusiveOr: case ExpressionType.Invoke: case ExpressionType.Lambda: case ExpressionType.LeftShift: case ExpressionType.ListInit: goto IL_71A; case ExpressionType.Call: { MethodCallExpression methodCallExpression = (MethodCallExpression)exp; bool flag = false; if (methodCallExpression.Object == null) { flag = true; this.m_writer.WriteStartElement("ExpressionStaticMethod"); string serverTypeId = ConditionalExpressionToXmlConverter.GetServerTypeId(methodCallExpression.Method.DeclaringType); if (string.IsNullOrEmpty(serverTypeId)) { throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } this.m_writer.WriteAttributeString("TypeId", serverTypeId); this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method)); } else { this.m_writer.WriteStartElement("ExpressionMethod"); this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(methodCallExpression.Method)); this.Write(methodCallExpression.Object); } this.m_writer.WriteStartElement("Parameters"); foreach (Expression current in methodCallExpression.Arguments) { if (flag) { flag = false; } else { this.Write(current); } } this.m_writer.WriteEndElement(); this.m_writer.WriteEndElement(); return; } case ExpressionType.Constant: { ConstantExpression constantExpression = (ConstantExpression)exp; object value = constantExpression.Value; //Edited for .NET Core //if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().IsPrimitive || value.GetType().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string)) if (value == null || value is ClientObject || value is ClientValueObject || value.GetType().GetTypeInfo().IsPrimitive || value.GetType().GetTypeInfo().IsEnum || value.GetType() == typeof(Guid) || value.GetType() == typeof(DateTime) || value.GetType() == typeof(string)) { this.m_writer.WriteStartElement("ExpressionConstant"); DataConvert.WriteValueToXmlElement(this.m_writer, value, this.m_serializationContext); this.m_writer.WriteEndElement(); return; } throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } case ExpressionType.Convert: case ExpressionType.ConvertChecked: { UnaryExpression unaryExpression = (UnaryExpression)exp; string value2 = null; string value3 = null; DataConvert.GetTypeNameOrTypeId(unaryExpression.Type, out value2, out value3); if (!string.IsNullOrEmpty(value2)) { this.m_writer.WriteStartElement("ExpressionConvert"); this.m_writer.WriteAttributeString("Type", value2); this.Write(unaryExpression.Operand); this.m_writer.WriteEndElement(); return; } if (string.IsNullOrEmpty(value3)) { throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } if (this.m_serializationContext.Context.RequestSchemaVersion >= ClientSchemaVersions.Version15) { this.m_writer.WriteStartElement("ExpressionConvert"); this.m_writer.WriteAttributeString("TypeId", value3); this.Write(unaryExpression.Operand); this.m_writer.WriteEndElement(); return; } this.Write(unaryExpression.Operand); return; } case ExpressionType.Equal: goto IL_D7; case ExpressionType.MemberAccess: { MemberExpression memberExpression = (MemberExpression)exp; if (!(memberExpression.Member is PropertyInfo)) { throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } if (ConditionalExpressionToXmlConverter.IsClientResultValueExpression(memberExpression)) { this.Write(memberExpression.Expression); return; } if (ConditionalExpressionToXmlConverter.IsServerObjectIsNullValue(memberExpression)) { this.Write(memberExpression.Expression); return; } if (memberExpression.Expression != null) { this.m_writer.WriteStartElement("ExpressionProperty"); this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member)); this.Write(memberExpression.Expression); this.m_writer.WriteEndElement(); return; } this.m_writer.WriteStartElement("ExpressionStaticProperty"); string serverTypeId2 = ConditionalExpressionToXmlConverter.GetServerTypeId(memberExpression.Member.DeclaringType); if (string.IsNullOrEmpty(serverTypeId2)) { throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } this.m_writer.WriteAttributeString("TypeId", serverTypeId2); this.m_writer.WriteAttributeString("Name", ConditionalExpressionToXmlConverter.GetMemberName(memberExpression.Member)); this.m_writer.WriteEndElement(); return; } default: switch (nodeType) { case ExpressionType.Not: { this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]); UnaryExpression unaryExpression2 = (UnaryExpression)exp; this.Write(unaryExpression2.Operand); this.m_writer.WriteEndElement(); return; } case ExpressionType.NotEqual: goto IL_D7; case ExpressionType.Or: goto IL_71A; case ExpressionType.OrElse: break; case ExpressionType.Parameter: { ParameterExpression parameterExpression = (ParameterExpression)exp; this.m_writer.WriteStartElement("ExpressionParameter"); this.m_writer.WriteAttributeString("Name", parameterExpression.Name); this.m_writer.WriteEndElement(); return; } default: { if (nodeType != ExpressionType.TypeIs) { goto IL_71A; } TypeBinaryExpression typeBinaryExpression = (TypeBinaryExpression)exp; string value4 = null; string value5 = null; DataConvert.GetTypeNameOrTypeId(typeBinaryExpression.TypeOperand, out value4, out value5); if (string.IsNullOrEmpty(value4) && string.IsNullOrEmpty(value5)) { throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); } this.m_writer.WriteStartElement("ExpressionTypeIs"); if (!string.IsNullOrEmpty(value4)) { this.m_writer.WriteAttributeString("Type", value4); } if (!string.IsNullOrEmpty(value5)) { this.m_writer.WriteAttributeString("TypeId", value5); } this.Write(typeBinaryExpression.Expression); this.m_writer.WriteEndElement(); return; } } break; } BinaryExpression binaryExpression = (BinaryExpression)exp; this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]); this.Write(binaryExpression.Left); this.Write(binaryExpression.Right); this.m_writer.WriteEndElement(); return; IL_D7: BinaryExpression binaryExpression2 = (BinaryExpression)exp; if (ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Left) || ConditionalExpressionToXmlConverter.IsNullExpression(binaryExpression2.Right) || (ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Right.Type) && ConditionalExpressionToXmlConverter.IsSupportedEqualType(binaryExpression2.Left.Type))) { this.m_writer.WriteStartElement(ConditionalExpressionToXmlConverter.s_opNames[exp.NodeType]); this.Write(binaryExpression2.Left); this.Write(binaryExpression2.Right); this.m_writer.WriteEndElement(); return; } throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); IL_71A: throw new ClientRequestException(Resources.GetString("NotSupportedExpression", new object[] { this.m_condition.ToString() })); }
private void TraverseTypeBinaryExpression(TypeBinaryExpression typeBinaryExpression) { TraverseExpression(typeBinaryExpression.Expression); }
internal override Expression VisitTypeIs(TypeBinaryExpression b) { throw new NotSupportedException(Strings.ALinq_TypeBinaryNotSupported); }
/// <summary>Visits the children of the <see cref="T:System.Linq.Expressions.TypeBinaryExpression"></see>.</summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { _box.Put(node.TypeOperand.GUID.ToByteArray()); return(base.VisitTypeBinary(node)); }
protected virtual void VisitTypeIs(TypeBinaryExpression type) { Visit(type.Expression); }
bool IEvaluatableExpressionFilter.IsEvaluatableTypeBinary(TypeBinaryExpression node) => true;
public void VisitTypeIs(TypeBinaryExpression b) { Visit(b.Expression); }
protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { var expr = Visit(b.Expression); return(UpdateTypeIs(b, expr, b.TypeOperand)); }
protected override Expression VisitTypeBinary(TypeBinaryExpression node) { return(base.VisitTypeBinary(node)); }
/// <summary> /// Visit type-is expression /// </summary> protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { Expression expr = this.Visit(b.Expression); return(expr != b.Expression ? Expression.TypeIs(expr, b.TypeOperand) : b); }
protected override Expression VisitTypeBinary(TypeBinaryExpression b) { throw InvalidSqlExpression(b); }
/// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { throw new NotSupportedException(string.Format(Resources.EX_PROCESS_NODE_NOT_SUPPORT, node.GetType().Name)); }
protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { Expression expr = this.Visit(b.Expression); return(this.UpdateTypeIs(b, expr, b.TypeOperand)); }
protected virtual bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b) { return(a.TypeOperand == b.TypeOperand && Compare(a.Expression, b.Expression)); }
/// <summary> /// If the result of a TypeBinaryExpression is known statically, this /// returns the result, otherwise it returns null, meaning we'll need /// to perform the IsInst instruction at runtime. /// /// The result of this function must be equivalent to IsInst, or /// null. /// </summary> internal static AnalyzeTypeIsResult AnalyzeTypeIs(TypeBinaryExpression typeIs) { return AnalyzeTypeIs(typeIs.Expression, typeIs.TypeOperand); }
protected override Expression VisitTypeBinaryExpression(TypeBinaryExpression expression) { return(expression); }
public TypeBinaryExpressionProxy(TypeBinaryExpression node) { _node = node; }
protected override Expression VisitTypeBinary(TypeBinaryExpression node) { Out(node.ToString()); return(node); }
protected internal virtual void PostWalk(TypeBinaryExpression node) { }
protected override Expression VisitTypeEqual(TypeBinaryExpression exp) { Accumulate(exp.TypeOperand); return base.VisitTypeEqual(exp); }