private void FreeTemp(ParameterExpression temp) { Debug.Assert(_freeTemps == null || !_freeTemps.Contains(temp)); if (_freeTemps == null) { _freeTemps = new List<ParameterExpression>(); } _freeTemps.Add(temp); }
internal LocalStorage(LambdaCompiler compiler, ParameterExpression variable) : base(compiler, variable) { // ByRef variables are supported. This is used internally by // the compiler when emitting an inlined lambda invoke, to // handle ByRef parameters. BlockExpression prevents this // from being exposed to user created trees. _local = compiler.GetNamedLocal(variable.IsByRef ? variable.Type.MakeByRefType() : variable.Type, variable); }
public void CreateSimpleDefCommand() { IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", null, false), new ParameterExpression("b", null, false) }; ICommand body = new SetCommand("c", new ConstantExpression(1)); DefCommand command = new DefCommand("foo", parameters, body); Assert.AreEqual("foo", command.Name); Assert.AreEqual(parameters, command.ParameterExpressions); Assert.AreEqual(body, command.Body); }
public StaticModuleGenerator(TypeBuilder class_builder, bool native_regex) { ClassBuilder = class_builder; NativeRegex = native_regex; Initializers = new List<Expression>(); Subroutines = new Dictionary<Subroutine, SubInfo>(); CreatedPackages = new HashSet<string>(); InitRuntime = Expression.Parameter(typeof(Runtime), "runtime"); Globals = new Dictionary<string, FieldInfo>(); }
private ParameterExpression UseTemp(ParameterExpression temp) { Debug.Assert(_freeTemps == null || !_freeTemps.Contains(temp)); Debug.Assert(_usedTemps == null || !_usedTemps.Contains(temp)); if (_usedTemps == null) { _usedTemps = new Stack<ParameterExpression>(); } _usedTemps.Push(temp); return temp; }
public SubGenerator() { Runtime = Expression.Parameter(typeof(Runtime), "runtime"); Arguments = Expression.Parameter(typeof(P5Array), "args"); Context = Expression.Parameter(typeof(Opcode.ContextValues), "context"); Pad = Expression.Parameter(typeof(P5ScratchPad), "pad"); Variables = new List<ParameterExpression>(); Lexicals = new List<ParameterExpression>(); Temporaries = new List<ParameterExpression>(); BlockLabels = new Dictionary<BasicBlock, LabelTarget>(); ValueBlocks = new Dictionary<BasicBlock, Expression>(); LexStates = new List<ParameterExpression>(); RxStates = new List<ParameterExpression>(); }
public void RaiseWhenNonDefaultArgumentFollowsDefaultArgument() { IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", new ConstantExpression(1), false), new ParameterExpression("b", null, false) }; ICommand body = new SetCommand("c", new ConstantExpression(1)); try { DefCommand command = new DefCommand("foo", parameters, body); Assert.Fail("Exception expected"); } catch (Exception ex) { Assert.IsInstanceOfType(ex, typeof(SyntaxError)); Assert.AreEqual("non-default argument follows default argument", ex.Message); } }
public void CreateAndEvaluateParameterExpressionWithNameAndList() { var expression = new ParameterExpression("a", null, true); var result = expression.Evaluate(null); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(Parameter)); var param = (Parameter)result; Assert.AreEqual("a", expression.Name); Assert.IsNull(expression.DefaultExpression); Assert.IsTrue(expression.IsList); Assert.AreEqual("a", param.Name); Assert.IsNull(param.DefaultValue); Assert.IsTrue(param.IsList); }
/// <summary> /// Extendses the specified parameter map. /// </summary> /// <param name="extend">The extend id.</param> /// <returns></returns> public ParameterExpression Extends(string extend) { Contract.Require.That(extend, Is.Not.Null & Is.Not.Empty).When("retrieving extend argument in Extends method"); if (parentConfiguration == null) { parameterExpression = new ParameterExpression(builder); parentConfiguration = builder.RegisterConfiguration(); parameterExpression.parentConfiguration = parentConfiguration; } if (parameterExpression == null) { parameterExpression = new ParameterExpression(builder); parameterExpression.parentConfiguration = parentConfiguration; } parentConfiguration.CreateAttribute(ConfigConstants.ATTRIBUTE_EXTENDS, builder.ApplyNamespace(extend)); return parameterExpression; }
internal HoistedLocals(HoistedLocals parent, ReadOnlyCollection<ParameterExpression> vars) { if (parent != null) { // Add the parent locals array as the 0th element in the array vars = vars.AddFirst(parent.SelfVariable); } Dictionary<Expression, int> indexes = new Dictionary<Expression, int>(vars.Count); for (int i = 0; i < vars.Count; i++) { indexes.Add(vars[i], i); } SelfVariable = Expression.Variable(typeof(object[]), name: null); Parent = parent; Variables = vars; Indexes = new ReadOnlyDictionary<Expression, int>(indexes); }
public void ExecuteSimpleDefCommand() { IList<ParameterExpression> parameters = new ParameterExpression[] { new ParameterExpression("a", null, false), new ParameterExpression("b", null, false) }; ICommand body = new SetCommand("c", new ConstantExpression(1)); DefCommand command = new DefCommand("foo", parameters, body); Machine machine = new Machine(); command.Execute(machine.Environment); var func = machine.Environment.GetValue("foo"); Assert.IsNotNull(func); Assert.IsInstanceOfType(func, typeof(IFunction)); Assert.IsInstanceOfType(func, typeof(DefinedFunction)); var dfunc = (DefinedFunction)func; Assert.AreEqual(parameters.Count, dfunc.Parameters.Count); Assert.AreEqual(body, dfunc.Body); }
public void CreateAndEvaluateParameterExpressionWithNameAndDefaultExpression() { var environment = new BindingEnvironment(); environment.SetValue("b", 1); var defaultExpression = new NameExpression("b"); var expression = new ParameterExpression("a", defaultExpression, false); var result = expression.Evaluate(environment); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(Parameter)); var param = (Parameter)result; Assert.AreEqual("a", expression.Name); Assert.AreEqual(defaultExpression, expression.DefaultExpression); Assert.IsFalse(expression.IsList); Assert.AreEqual("a", param.Name); Assert.AreEqual(1, param.DefaultValue); Assert.IsFalse(param.IsList); }
public ParameterExpressionProxy(ParameterExpression node) { _node = node; }
public LightExceptionCheckExpression(Expression expr, Type retType, LabelTarget currentHandler, ParameterExpression lastValue) { _expr = expr; _retType = retType; _target = currentHandler; _lastValue = lastValue; }
/// <summary> /// 替换参数 /// </summary> /// <typeparam name="T">动态实体</typeparam> /// <param name="expr1"></param> /// <param name="expr2"></param> /// <param name="newParameter"></param> /// <returns></returns> public static (Expression left, Expression right) ReplaceParameter <T>(this Expression <Func <T, bool> > expr1, Expression <Func <T, bool> > expr2, out ParameterExpression newParameter) {
/// <summary> /// False coalescing expression. /// {result} ::= IsTrue(tmp = {left}) ? tmp : {right} /// Generalized OR semantics. /// </summary> public static Expression CoalesceFalse(Expression left, Expression right, MethodInfo isTrue, out ParameterExpression temp) { ContractUtils.RequiresNotNull(isTrue, "isTrue"); return(CoalesceInternal(left, right, isTrue, true, out temp)); }
public static Expression<Func<ValueObject, string>> GetSelectDimension(string nomDimension) { ParameterExpression param = Expression.Parameter(typeof(ValueObject), "x"); MemberExpression member = Expression.Property(param, nomDimension); return Expression.Lambda<Func<ValueObject, string>>(member, param); }
private void AddressOf(ParameterExpression node, Type type) { if (TypeUtils.AreEquivalent(type, node.Type)) { if (node.IsByRef) { _scope.EmitGet(node); } else { _scope.EmitAddressOf(node); } } else { EmitExpressionAddress(node, type); } }
internal Storage(LambdaCompiler compiler, ParameterExpression variable) { Compiler = compiler; Variable = variable; }
/// <summary> /// Creates a <see cref="CatchBlock"/> representing a catch statement with /// an <see cref="Exception"/> filter and a reference to the caught <see cref="Exception"/> object. /// </summary> /// <param name="variable">A <see cref="ParameterExpression"/> representing a reference to the <see cref="Exception"/> object caught by this handler.</param> /// <param name="body">The body of the catch statement.</param> /// <param name="filter">The body of the <see cref="Exception"/> filter.</param> /// <returns>The created <see cref="CatchBlock"/>.</returns> public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter) { ContractUtils.RequiresNotNull(variable, "variable"); return(MakeCatchBlock(variable.Type, variable, body, filter)); }
public StatisVisitor(ParameterExpression newParamter) { _newParamter = newParamter; }
private IList <MemberAssignment> ProcessEntry(SelectEntry entry, ParameterExpression parameter, string suffix = "") { List <MemberAssignment> bindings = new List <MemberAssignment>(); Type type = parameter.Type; //process the sub properties if (entry.Childs.Count > 0) { PropertyInfo propertyInfo = Utils.GetPropertyInfo(parameter.Type, entry.Property); MemberExpression originalMember = Expression.Property(parameter, propertyInfo); Type childType = propertyInfo.PropertyType; ParameterExpression childParameter = Expression.Parameter(childType, entry.Property); List <MemberAssignment> subBindings = new List <MemberAssignment>(); var isCollection = Utils.IsEnumerable(childParameter); //The property is a Enumerable if (isCollection) { // Get the type of the child elements Type elementType = childType.GetGenericArguments()[0]; // Create an expression for the parameter ParameterExpression elementParameter = Expression.Parameter(elementType, entry.Property + ".Element"); foreach (SelectEntry e in entry.Childs) { subBindings.AddRange(ProcessEntry(e, elementParameter)); } // Convert the list to Queryable Expression asQueryable = Utils.AsQueryable(childParameter); //Expression to generate a new element of the list NewExpression newElementExpression = Expression.New(elementType); MemberInitExpression initElementExpression = Expression.MemberInit(newElementExpression, subBindings); //Iterate over the original elements (Queryable.Select) MethodCallExpression selectExpr = Expression.Call(typeof(Queryable), "Select", new[] { elementType, elementType }, asQueryable, MakeLambda(initElementExpression, elementParameter)); //Convert the result to list Expression toListCall = Expression.Call(typeof(Enumerable), "ToList", selectExpr.Type.GetGenericArguments(), selectExpr); // Check for null original collection (avoid null pointer) Expression notNullConditionExpression = Expression.NotEqual(childParameter, Expression.Constant(null, childParameter.Type)); Expression trueExpression = MakeLambda(Expression.Convert(toListCall, childParameter.Type), childParameter); Expression falseExpression = MakeLambda(Expression.Constant(null, childParameter.Type), childParameter); Expression notNullExpression = Expression.Condition(notNullConditionExpression, trueExpression, falseExpression); Expression notNullLambda = MakeLambda(Expression.Invoke(notNullExpression, originalMember), childParameter); //Invocate the null-check expression Expression invocation = Expression.Invoke(notNullLambda, originalMember); // Add the invocation to the bindings on the original element bindings.Add(Expression.Bind(propertyInfo, invocation)); } else { // Add the child entities to the initialization bindings of the object foreach (SelectEntry e in entry.Childs) { subBindings.AddRange(ProcessEntry(e, childParameter)); } // Add the lambda to the bindings of the property in the parent object bindings.Add(Expression.Bind(propertyInfo, CreateNewObject(childParameter, childType, subBindings, originalMember))); } } else { // Add the property to the init bindings bindings.Add(AssignProperty(parameter.Type, entry.Property, parameter)); } return(bindings); }
public override Expression GetSerializerExpression(Type memberType, Expression getterExp, ParameterExpression writerExp) { Debug.Assert(_innerBuilder != null, "Underlying builder can't be null for CheckNullBuilder"); if (memberType.GetTypeInfo().IsValueType) { return(_innerBuilder.GetSerializerExpression(memberType, getterExp, writerExp)); } var boolType = typeof(bool); var valueExp = getterExp; var writeMethod = GetWriterMethod("Write", boolType); var bodyExp = _innerBuilder.GetSerializerExpression(memberType, getterExp, writerExp); return(Expression.IfThenElse( Expression.Equal(valueExp, Expression.Constant(null, memberType)), Expression.Call(writerExp, writeMethod, Expression.Constant(false, boolType)), Expression.Block(Expression.Call(writerExp, writeMethod, Expression.Constant(true, boolType)), bodyExp))); }
protected override Expression VisitParameter(ParameterExpression parameter) { Add(parameter.Name.GetHashCode()); return(parameter); }
static Expression <Func <TEntity, bool> > BuildPredicate <TEntity>(object key) { /* * key: * 如果实体是单一主键,则传入的 key 与主键属性类型相同的值 * 如果实体是多主键,则传入的 key 须是包含了与实体主键类型相同的属性的对象,如:new { Key1 = "1", Key2 = "2" } */ Utils.CheckNull(key); Type entityType = typeof(TEntity); TypeDescriptor typeDescriptor = TypeDescriptor.GetDescriptor(entityType); EnsureEntityHasPrimaryKey(typeDescriptor); KeyValuePairList <MemberInfo, object> keyValueMap = new KeyValuePairList <MemberInfo, object>(); if (typeDescriptor.PrimaryKeys.Count == 1) { keyValueMap.Add(typeDescriptor.PrimaryKeys[0].MemberInfo, key); } else { /* * key: new { Key1 = "1", Key2 = "2" } */ object multipleKeyObject = key; Type multipleKeyObjectType = multipleKeyObject.GetType(); for (int i = 0; i < typeDescriptor.PrimaryKeys.Count; i++) { MappingMemberDescriptor keyMemberDescriptor = typeDescriptor.PrimaryKeys[i]; MemberInfo keyMember = multipleKeyObjectType.GetProperty(keyMemberDescriptor.MemberInfo.Name); if (keyMember == null) { throw new ArgumentException(string.Format("The input object does not define property for key '{0}'.", keyMemberDescriptor.MemberInfo.Name)); } object value = keyMember.GetMemberValue(multipleKeyObject); if (value == null) { throw new ArgumentException(string.Format("The primary key '{0}' could not be null.", keyMemberDescriptor.MemberInfo.Name)); } keyValueMap.Add(keyMemberDescriptor.MemberInfo, value); } } ParameterExpression parameter = Expression.Parameter(entityType, "a"); Expression lambdaBody = null; foreach (var keyValue in keyValueMap) { Expression propOrField = Expression.PropertyOrField(parameter, keyValue.Key.Name); Expression wrappedValue = Chloe.Extensions.ExpressionExtension.MakeWrapperAccess(keyValue.Value, keyValue.Key.GetMemberType()); Expression e = Expression.Equal(propOrField, wrappedValue); lambdaBody = lambdaBody == null ? e : Expression.AndAlso(lambdaBody, e); } Expression <Func <TEntity, bool> > predicate = Expression.Lambda <Func <TEntity, bool> >(lambdaBody, parameter); return(predicate); }
public NewExpressionVisitor(ParameterExpression param) { this._NewParameter = param; }
/// <summary> /// Creates a <see cref="CatchBlock"/> representing a catch statement with /// an <see cref="Exception"/> filter and a reference to the caught <see cref="Exception"/> object. /// </summary> /// <param name="variable">A <see cref="ParameterExpression"/> representing a reference to the <see cref="Exception"/> object caught by this handler.</param> /// <param name="body">The body of the catch statement.</param> /// <param name="filter">The body of the <see cref="Exception"/> filter.</param> /// <returns>The created <see cref="CatchBlock"/>.</returns> public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter) { ContractUtils.RequiresNotNull(variable, "variable"); return MakeCatchBlock(variable.Type, variable, body, filter); }
protected override Expression VisitParameter(ParameterExpression node) { return(_newParamter); }
internal CatchBlock(Type test, ParameterExpression variable, Expression body, Expression filter) { _test = test; _var = variable; _body = body; _filter = filter; }
/// <summary> /// Null coalescing expression /// {result} ::= ((tmp = {_left}) == null) ? {right} : tmp /// '??' operator in C#. /// </summary> public static Expression Coalesce(Expression left, Expression right, out ParameterExpression temp) { return(CoalesceInternal(left, right, null, false, out temp)); }
internal ElementBoxStorage(Storage array, int index, ParameterExpression variable) : base(array.Compiler, variable) { _array = array; _index = index; _boxType = typeof(StrongBox<>).MakeGenericType(variable.Type); _boxValueField = _boxType.GetField("Value"); }
private void CacheBoxToLocal(LambdaCompiler lc, ParameterExpression v) { Debug.Assert(ShouldCache(v) && !_locals.ContainsKey(v)); var local = new LocalBoxStorage(lc, v); local.EmitStoreBox(); _locals.Add(v, local); }
/// <summary> /// Parser语法分析器 /// </summary> /// <param name="parameter">参数表达式</param> /// <param name="expression"></param> /// <returns></returns> private static Expression Parser(ParameterExpression parameter, Expression expression) { if (expression == null) { return(null); } switch (expression.NodeType) { //一元运算符 case ExpressionType.Negate: case ExpressionType.NegateChecked: case ExpressionType.Not: case ExpressionType.Convert: case ExpressionType.ConvertChecked: case ExpressionType.ArrayLength: case ExpressionType.Quote: case ExpressionType.TypeAs: { var unary = expression as UnaryExpression; var exp = Parser(parameter, unary.Operand); return(Expression.MakeUnary(expression.NodeType, exp, unary.Type, unary.Method)); } //二元运算符 case ExpressionType.Add: case ExpressionType.AddChecked: case ExpressionType.Subtract: case ExpressionType.SubtractChecked: case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: case ExpressionType.Divide: case ExpressionType.Modulo: case ExpressionType.And: case ExpressionType.AndAlso: case ExpressionType.Or: case ExpressionType.OrElse: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: case ExpressionType.Equal: case ExpressionType.NotEqual: case ExpressionType.Coalesce: case ExpressionType.ArrayIndex: case ExpressionType.RightShift: case ExpressionType.LeftShift: case ExpressionType.ExclusiveOr: { var binary = expression as BinaryExpression; var left = Parser(parameter, binary.Left); var right = Parser(parameter, binary.Right); var conversion = Parser(parameter, binary.Conversion); if (binary.NodeType == ExpressionType.Coalesce && binary.Conversion != null) { return(Expression.Coalesce(left, right, conversion as LambdaExpression)); } else { return(Expression.MakeBinary(expression.NodeType, left, right, binary.IsLiftedToNull, binary.Method)); } } //其他 case ExpressionType.Call: { var call = expression as MethodCallExpression; List <Expression> arguments = new List <Expression>(); foreach (var argument in call.Arguments) { arguments.Add(Parser(parameter, argument)); } var instance = Parser(parameter, call.Object); call = Expression.Call(instance, call.Method, arguments); return(call); } case ExpressionType.Lambda: { var lambda = expression as LambdaExpression; return(Parser(parameter, lambda.Body)); } case ExpressionType.MemberAccess: { var memberAccess = expression as MemberExpression; if (memberAccess.Expression == null) { memberAccess = Expression.MakeMemberAccess(null, memberAccess.Member); } else { var exp = Parser(parameter, memberAccess.Expression); var member = exp.Type.GetMember(memberAccess.Member.Name).FirstOrDefault(); memberAccess = Expression.MakeMemberAccess(exp, member); } return(memberAccess); } case ExpressionType.Parameter: return(parameter); case ExpressionType.Constant: return(expression); case ExpressionType.TypeIs: { var typeis = expression as TypeBinaryExpression; var exp = Parser(parameter, typeis.Expression); return(Expression.TypeIs(exp, typeis.TypeOperand)); } default: throw new Exception($"Unhandled expression type:{expression.NodeType}"); } }
private void AddressOf(ParameterExpression node, Type type) { if (type == node.Type) { if (node.IsByRef) { _scope.EmitGet(node); } else { _scope.EmitAddressOf(node); } } else { EmitExpressionAddress(node, type); } }
protected override Expression VisitParameter(ParameterExpression node) { return(ChangeSource_VisitParameter(node, _paramters)); }
protected override Expression VisitParameter(ParameterExpression p) { return(this.ParameterExpression); }
private void CombineExp(Expression <Func <T, bool> > expression, bool condition, ParameterExpression parameter, Func <Expression, Expression, BinaryExpression> exp) { if (condition) { if (filter != null) { Expression left = Rebuild(filter.Body, parameter); Expression right = Rebuild(expression.Body, parameter); filter = (Expression <Func <T, bool> >)Expression.Lambda(exp(left, right), parameter); } else if (filter == null) { filter = expression; } } }
/// <summary> /// Gets a filter expression to be used as part of a AttributeValue Query or EntityAttributeQueryExpression /// </summary> /// <param name="configurationValues">The configuration values.</param> /// <param name="filterValues">The filter values: FieldName, <see cref="ComparisonType">Comparison Type</see>, (optional) Comparison Value(s)</param> /// <param name="parameterExpression">The parameter expression.</param> /// <returns></returns> public virtual Expression AttributeFilterExpression( Dictionary<string, ConfigurationValue> configurationValues, List<string> filterValues, ParameterExpression parameterExpression ) { // If filterValues.Count >= 2, then filterValues[0] is ComparisonType, and filterValues[1] is a CompareToValue. Otherwise, filterValues[0] is a CompareToValue (for example, a SingleSelect attribute) if ( filterValues.Count >= 2 ) { ComparisonType? comparisonType = filterValues[0].ConvertToEnumOrNull<ComparisonType>(); if ( comparisonType.HasValue ) { string compareToValue = filterValues[1]; MemberExpression propertyExpression = Expression.Property( parameterExpression, this.AttributeValueFieldName ); if ( !string.IsNullOrWhiteSpace( compareToValue ) ) { // both a comparison type and value are specified, so we can process normally return ComparisonHelper.ComparisonExpression( comparisonType.Value, propertyExpression, AttributeConstantExpression( compareToValue ) ); } else { // No comparison value was specified, so we can filter if the Comparison Type using no value still makes sense if ( ( ComparisonType.IsBlank | ComparisonType.IsNotBlank ).HasFlag( comparisonType ) ) { // Just checking if IsBlank or IsNotBlank, so let ComparisonExpression do its thing return ComparisonHelper.ComparisonExpression( comparisonType.Value, propertyExpression, AttributeConstantExpression( string.Empty ) ); } else if ( this.FilterComparisonType.HasFlag( ComparisonType.IsBlank ) ) { // if this Filter supports IsBlank/IsNotBlank, we can convert this to IsBlank/IsNotBlank if no value was specified if ( comparisonType == ComparisonType.EqualTo ) { // an EqualTo was specified, but no value was specified, so convert it to a IsBlank return ComparisonHelper.ComparisonExpression( ComparisonType.IsBlank, propertyExpression, AttributeConstantExpression( string.Empty ) ); } else if ( comparisonType == ComparisonType.NotEqualTo ) { // a NotEqualTo was specified, but no value was specified, so convert it to a IsNotBlank return ComparisonHelper.ComparisonExpression( ComparisonType.IsNotBlank, propertyExpression, AttributeConstantExpression( string.Empty ) ); } } } } else { // No comparison type specified, so return NoAttributeFilterExpression ( which means don't filter ) return new NoAttributeFilterExpression(); } } // return NoAttributeFilterExpression ( which means don't filter ) if there isn't enough information to make a Comparison Expression return new NoAttributeFilterExpression(); }
private Expression ReduceIndex() { // left[a0, a1, ... aN] (op) // // ... is reduced into ... // // tempObj = left // tempArg0 = a0 // ... // tempArgN = aN // tempValue = tempObj[tempArg0, ... tempArgN] // tempObj[tempArg0, ... tempArgN] = op(tempValue) // tempValue bool prefix = IsPrefix; var index = (IndexExpression)_operand; int count = index.Arguments.Count; var block = new Expression[count + (prefix ? 2 : 4)]; var temps = new ParameterExpression[count + (prefix ? 1 : 2)]; var args = new ParameterExpression[count]; int i = 0; temps[i] = Parameter(index.Object.Type, null); block[i] = Assign(temps[i], index.Object); i++; while (i <= count) { var arg = index.Arguments[i - 1]; args[i - 1] = temps[i] = Parameter(arg.Type, null); block[i] = Assign(temps[i], arg); i++; } index = MakeIndex(temps[0], index.Indexer, new TrueReadOnlyCollection<Expression>(args)); if (!prefix) { var lastTemp = temps[i] = Parameter(index.Type, null); block[i] = Assign(temps[i], index); i++; Debug.Assert(i == temps.Length); block[i++] = Assign(index, FunctionalOp(lastTemp)); block[i++] = lastTemp; } else { Debug.Assert(i == temps.Length); block[i++] = Assign(index, FunctionalOp(index)); } Debug.Assert(i == block.Length); return Block(new TrueReadOnlyCollection<ParameterExpression>(temps), new TrueReadOnlyCollection<Expression>(block)); }
/// <summary> /// Gets a filter expression for an attribute value. /// </summary> /// <param name="configurationValues">The configuration values.</param> /// <param name="filterValues">The filter values.</param> /// <param name="parameterExpression">The parameter expression.</param> /// <returns></returns> public override Expression AttributeFilterExpression(Dictionary <string, ConfigurationValue> configurationValues, List <string> filterValues, ParameterExpression parameterExpression) { if (filterValues.Count == 1) { MemberExpression propertyExpression = Expression.Property(parameterExpression, "ValueAsNumeric"); ComparisonType comparisonType = ComparisonType.EqualTo; return(ComparisonHelper.ComparisonExpression(comparisonType, propertyExpression, AttributeConstantExpression(filterValues[0]))); } return(base.AttributeFilterExpression(configurationValues, filterValues, parameterExpression)); }
private static ParameterExpression NewParameter(ParameterExpression parameterExpression) { return(Expression.Variable(parameterExpression.Type, parameterExpression.Name)); }
public RebindParameterVisitor(ParameterExpression oldParameter, ParameterExpression newParameter) { _oldParameter = oldParameter; _newParameter = newParameter; }
private void EmitBinaryMethod(BinaryExpression b, CompilationFlags flags) { if (b.IsLifted) { ParameterExpression p1 = Expression.Variable(TypeUtils.GetNonNullableType(b.Left.Type), null); ParameterExpression p2 = Expression.Variable(TypeUtils.GetNonNullableType(b.Right.Type), null); MethodCallExpression mc = Expression.Call(null, b.Method, p1, p2); Type resultType = null; if (b.IsLiftedToNull) { resultType = TypeUtils.GetNullableType(mc.Type); } else { switch (b.NodeType) { case ExpressionType.Equal: case ExpressionType.NotEqual: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: if (mc.Type != typeof(bool)) { throw Error.ArgumentMustBeBoolean(); } resultType = typeof(bool); break; default: resultType = TypeUtils.GetNullableType(mc.Type); break; } } var variables = new ParameterExpression[] { p1, p2 }; var arguments = new Expression[] { b.Left, b.Right }; ValidateLift(variables, arguments); EmitLift(b.NodeType, resultType, mc, variables, arguments); } else { EmitMethodCallExpression(Expression.Call(null, b.Method, b.Left, b.Right), flags); } }
protected virtual Expression VisitParameter(ParameterExpression p) { return(p); }
protected override Expression VisitParameter(ParameterExpression node) { return Expression.Parameter(node.IsByRef ? node.Type.MakeByRefType() : node.Type, node.Name); }
public virtual void PushdownIntoSubquery() { var clientProjection = _valueBufferSlots.Count != 0; if (!clientProjection) { var result = new Dictionary <ProjectionMember, Expression>(); foreach (var keyValuePair in _projectionMapping) { if (keyValuePair.Value is EntityProjectionExpression entityProjection) { var map = new Dictionary <IProperty, Expression>(); foreach (var property in GetAllPropertiesInHierarchy(entityProjection.EntityType)) { var expressionToAdd = entityProjection.BindProperty(property); var index = AddToProjection(expressionToAdd); map[property] = CreateReadValueExpression(expressionToAdd.Type, index, property); } result[keyValuePair.Key] = new EntityProjectionExpression(entityProjection.EntityType, map); } else { var index = AddToProjection(keyValuePair.Value); result[keyValuePair.Key] = CreateReadValueExpression( keyValuePair.Value.Type, index, InferPropertyFromInner(keyValuePair.Value)); } } _projectionMapping = result; } var selectorLambda = Lambda( New( _valueBufferConstructor, NewArrayInit( typeof(object), _valueBufferSlots .Select(e => e.Type.IsValueType ? Convert(e, typeof(object)) : e))), CurrentParameter); _groupingParameter = null; ServerQueryExpression = Call( FileContextLinqOperatorProvider.Select.MakeGenericMethod(ServerQueryExpression.Type.TryGetSequenceType(), typeof(ValueBuffer)), ServerQueryExpression, selectorLambda); if (clientProjection) { var newValueBufferSlots = _valueBufferSlots .Select((e, i) => CreateReadValueExpression(e.Type, i, InferPropertyFromInner(e))) .ToList(); _valueBufferSlots.Clear(); _valueBufferSlots.AddRange(newValueBufferSlots); } else { _valueBufferSlots.Clear(); } }
protected override Expression VisitParameter(ParameterExpression node) { return Expression.Parameter(node.Type, node.Name); // clones }
/// <inheritdoc /> protected abstract override T VisitParameter(ParameterExpression node);
/// <summary> /// Creates a <see cref="CatchBlock"/> representing a catch statement with the specified elements. /// </summary> /// <param name="type">The <see cref="Type"/> of <see cref="Exception"/> this <see cref="CatchBlock"/> will handle.</param> /// <param name="variable">A <see cref="ParameterExpression"/> representing a reference to the <see cref="Exception"/> object caught by this handler.</param> /// <param name="body">The body of the catch statement.</param> /// <param name="filter">The body of the <see cref="Exception"/> filter.</param> /// <returns>The created <see cref="CatchBlock"/>.</returns> /// <remarks><paramref name="type"/> must be non-null and match the type of <paramref name="variable"/> (if it is supplied).</remarks> public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter) { ContractUtils.RequiresNotNull(type, "type"); ContractUtils.Requires(variable == null || TypeUtils.AreEquivalent(variable.Type, type), "variable"); if (variable != null && variable.IsByRef) { throw Error.VariableMustNotBeByRef(variable, variable.Type); } RequiresCanRead(body, "body"); if (filter != null) { RequiresCanRead(filter, "filter"); if (filter.Type != typeof(bool)) throw Error.ArgumentMustBeBoolean(); } return new CatchBlock(type, variable, body, filter); }
internal ArgumentStorage(LambdaCompiler compiler, ParameterExpression p) : base(compiler, p) { _argument = compiler.GetLambdaArgument(compiler.Parameters.IndexOf(p)); }
/// <summary> /// Creates a new expression that is like this one, but using the /// supplied children. If all of the children are the same, it will /// return this expression. /// </summary> /// <param name="variable">The <see cref="Variable" /> property of the result.</param> /// <param name="filter">The <see cref="Filter" /> property of the result.</param> /// <param name="body">The <see cref="Body" /> property of the result.</param> /// <returns>This expression if no children changed, or an expression with the updated children.</returns> public CatchBlock Update(ParameterExpression variable, Expression filter, Expression body) { if (variable == Variable && filter == Filter && body == Body) { return this; } return Expression.MakeCatchBlock(Test, variable, body, filter); }
protected override SequenceConvertInfo Convert( ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param) { if (methodCall.Arguments.Count == 2) { var predicate = (LambdaExpression)methodCall.Arguments[1].Unwrap(); var info = builder.ConvertSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]), predicate.Parameters[0]); if (info != null) { info.Expression = methodCall.Transform(ex => ConvertMethod(methodCall, 0, info, predicate.Parameters[0], ex)); info.Parameter = param; return(info); } } else { var info = builder.ConvertSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]), null); if (info != null) { info.Expression = methodCall.Transform(ex => ConvertMethod(methodCall, 0, info, null, ex)); info.Parameter = param; return(info); } } return(null); }
private void EmitLift(ExpressionType nodeType, Type resultType, MethodCallExpression mc, ParameterExpression[] paramList, Expression[] argList) { Debug.Assert(TypeUtils.AreEquivalent(TypeUtils.GetNonNullableType(resultType), TypeUtils.GetNonNullableType(mc.Type))); switch (nodeType) { default: case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: { Label exit = _ilg.DefineLabel(); Label exitNull = _ilg.DefineLabel(); LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool)); for (int i = 0, n = paramList.Length; i < n; i++) { ParameterExpression v = paramList[i]; Expression arg = argList[i]; if (TypeUtils.IsNullableType(arg.Type)) { _scope.AddLocal(this, v); EmitAddress(arg, arg.Type); _ilg.Emit(OpCodes.Dup); _ilg.EmitHasValue(arg.Type); _ilg.Emit(OpCodes.Ldc_I4_0); _ilg.Emit(OpCodes.Ceq); _ilg.Emit(OpCodes.Stloc, anyNull); _ilg.EmitGetValueOrDefault(arg.Type); _scope.EmitSet(v); } else { _scope.AddLocal(this, v); EmitExpression(arg); if (!arg.Type.GetTypeInfo().IsValueType) { _ilg.Emit(OpCodes.Dup); _ilg.Emit(OpCodes.Ldnull); _ilg.Emit(OpCodes.Ceq); _ilg.Emit(OpCodes.Stloc, anyNull); } _scope.EmitSet(v); } _ilg.Emit(OpCodes.Ldloc, anyNull); _ilg.Emit(OpCodes.Brtrue, exitNull); } EmitMethodCallExpression(mc); if (TypeUtils.IsNullableType(resultType) && !TypeUtils.AreEquivalent(resultType, mc.Type)) { ConstructorInfo ci = resultType.GetConstructor(new Type[] { mc.Type }); _ilg.Emit(OpCodes.Newobj, ci); } _ilg.Emit(OpCodes.Br_S, exit); _ilg.MarkLabel(exitNull); if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type))) { if (resultType.GetTypeInfo().IsValueType) { LocalBuilder result = GetLocal(resultType); _ilg.Emit(OpCodes.Ldloca, result); _ilg.Emit(OpCodes.Initobj, resultType); _ilg.Emit(OpCodes.Ldloc, result); FreeLocal(result); } else { _ilg.Emit(OpCodes.Ldnull); } } else { switch (nodeType) { case ExpressionType.LessThan: case ExpressionType.LessThanOrEqual: case ExpressionType.GreaterThan: case ExpressionType.GreaterThanOrEqual: _ilg.Emit(OpCodes.Ldc_I4_0); break; default: throw Error.UnknownLiftType(nodeType); } } _ilg.MarkLabel(exit); return; } case ExpressionType.Equal: case ExpressionType.NotEqual: { if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type))) { goto default; } Label exit = _ilg.DefineLabel(); Label exitAllNull = _ilg.DefineLabel(); Label exitAnyNull = _ilg.DefineLabel(); LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool)); LocalBuilder allNull = _ilg.DeclareLocal(typeof(bool)); _ilg.Emit(OpCodes.Ldc_I4_0); _ilg.Emit(OpCodes.Stloc, anyNull); _ilg.Emit(OpCodes.Ldc_I4_1); _ilg.Emit(OpCodes.Stloc, allNull); for (int i = 0, n = paramList.Length; i < n; i++) { ParameterExpression v = paramList[i]; Expression arg = argList[i]; _scope.AddLocal(this, v); if (TypeUtils.IsNullableType(arg.Type)) { EmitAddress(arg, arg.Type); _ilg.Emit(OpCodes.Dup); _ilg.EmitHasValue(arg.Type); _ilg.Emit(OpCodes.Ldc_I4_0); _ilg.Emit(OpCodes.Ceq); _ilg.Emit(OpCodes.Dup); _ilg.Emit(OpCodes.Ldloc, anyNull); _ilg.Emit(OpCodes.Or); _ilg.Emit(OpCodes.Stloc, anyNull); _ilg.Emit(OpCodes.Ldloc, allNull); _ilg.Emit(OpCodes.And); _ilg.Emit(OpCodes.Stloc, allNull); _ilg.EmitGetValueOrDefault(arg.Type); } else { EmitExpression(arg); if (!arg.Type.GetTypeInfo().IsValueType) { _ilg.Emit(OpCodes.Dup); _ilg.Emit(OpCodes.Ldnull); _ilg.Emit(OpCodes.Ceq); _ilg.Emit(OpCodes.Dup); _ilg.Emit(OpCodes.Ldloc, anyNull); _ilg.Emit(OpCodes.Or); _ilg.Emit(OpCodes.Stloc, anyNull); _ilg.Emit(OpCodes.Ldloc, allNull); _ilg.Emit(OpCodes.And); _ilg.Emit(OpCodes.Stloc, allNull); } else { _ilg.Emit(OpCodes.Ldc_I4_0); _ilg.Emit(OpCodes.Stloc, allNull); } } _scope.EmitSet(v); } _ilg.Emit(OpCodes.Ldloc, allNull); _ilg.Emit(OpCodes.Brtrue, exitAllNull); _ilg.Emit(OpCodes.Ldloc, anyNull); _ilg.Emit(OpCodes.Brtrue, exitAnyNull); EmitMethodCallExpression(mc); if (TypeUtils.IsNullableType(resultType) && !TypeUtils.AreEquivalent(resultType, mc.Type)) { ConstructorInfo ci = resultType.GetConstructor(new Type[] { mc.Type }); _ilg.Emit(OpCodes.Newobj, ci); } _ilg.Emit(OpCodes.Br_S, exit); _ilg.MarkLabel(exitAllNull); _ilg.EmitBoolean(nodeType == ExpressionType.Equal); _ilg.Emit(OpCodes.Br_S, exit); _ilg.MarkLabel(exitAnyNull); _ilg.EmitBoolean(nodeType == ExpressionType.NotEqual); _ilg.MarkLabel(exit); return; } } }
public RemoteGroupExpressionCompiler(GroupingInfo[] grouping, SummaryInfo[] totalSummary, SummaryInfo[] groupSummary) : base(false) { _groupByParam = CreateItemParam(typeof(T)); if (grouping != null) { foreach (var i in grouping) { var selectorExpr = CompileAccessorExpression(_groupByParam, i.Selector); if (!String.IsNullOrEmpty(i.GroupInterval)) { var groupIntervalExpr = CompileGroupInterval(selectorExpr, i.GroupInterval); if (Utils.CanAssignNull(selectorExpr.Type)) { var nullableType = typeof(Nullable <>).MakeGenericType(groupIntervalExpr.Type); var nullConst = Expression.Constant(null, nullableType); var test = Expression.Equal(selectorExpr, nullConst); groupIntervalExpr = Expression.Convert(groupIntervalExpr, nullableType); selectorExpr = Expression.Condition(test, nullConst, groupIntervalExpr); } else { selectorExpr = groupIntervalExpr; } } _groupKeyExprList.Add(selectorExpr); _descendingList.Add(i.Desc); } } if (totalSummary != null) { InitSummary(totalSummary, _totalSummaryExprList, _totalSummaryTypes, _totalSummaryParams); } if (_groupKeyExprList.Any() && groupSummary != null) { InitSummary(groupSummary, _groupSummaryExprList, _groupSummaryTypes, _groupSummaryParams); } if (_groupKeyExprList.Count > MAX_GROUPS) { throw new NotSupportedException($"Maximum number of groups ({MAX_GROUPS}) exceeded"); } if (_totalSummaryExprList.Count > MAX_AGGREGATES) { throw new NotSupportedException($"Maximum number of total-summary aggregates ({MAX_AGGREGATES}) exceeded"); } if (_groupSummaryExprList.Count > MAX_AGGREGATES) { throw new NotSupportedException($"Maximum number of group-summary aggregates ({MAX_AGGREGATES}) exceeded"); } var typeArguments = new List <Type>(MAX_GROUPS + 2 * MAX_AGGREGATES); for (var i = 0; i < MAX_GROUPS; i++) { typeArguments.Add(i < _groupKeyExprList.Count ? _groupKeyExprList[i].Type : typeof(Object)); } for (var i = 0; i < MAX_AGGREGATES; i++) { typeArguments.Add(i < _totalSummaryExprList.Count ? _totalSummaryExprList[i].Type : typeof(Object)); } for (var i = 0; i < MAX_AGGREGATES; i++) { typeArguments.Add(i < _groupSummaryExprList.Count ? _groupSummaryExprList[i].Type : typeof(Object)); } _remoteGroupClassType = typeof(RemoteGroup <, , , , , , , , , , , , , , , , , , , , , , ,>).MakeGenericType(typeArguments.ToArray()); }
internal LocalBoxStorage(LambdaCompiler compiler, ParameterExpression variable) : base(compiler, variable) { _boxType = typeof(StrongBox<>).MakeGenericType(variable.Type); _boxValueField = _boxType.GetField("Value"); _boxLocal = compiler.GetNamedLocal(_boxType, variable); }
private static Expression CoalesceInternal(Expression left, Expression right, MethodInfo isTrue, bool isReverse, out ParameterExpression temp) { ContractUtils.RequiresNotNull(left, "left"); ContractUtils.RequiresNotNull(right, "right"); // A bit too strict, but on a safe side. ContractUtils.Requires(left.Type == right.Type, "Expression types must match"); temp = Expression.Variable(left.Type, "tmp_left"); Expression condition; if (isTrue != null) { ContractUtils.Requires(isTrue.ReturnType == typeof(bool), "isTrue", "Predicate must return bool."); ParameterInfo[] parameters = isTrue.GetParameters(); ContractUtils.Requires(parameters.Length == 1, "isTrue", "Predicate must take one parameter."); ContractUtils.Requires(isTrue.IsStatic && isTrue.IsPublic, "isTrue", "Predicate must be public and static."); Type pt = parameters[0].ParameterType; ContractUtils.Requires(TypeUtils.CanAssign(pt, left.Type), "left", "Incorrect left expression type"); condition = Expression.Call(isTrue, Expression.Assign(temp, left)); } else { ContractUtils.Requires(TypeUtils.CanCompareToNull(left.Type), "left", "Incorrect left expression type"); condition = Expression.Equal(Expression.Assign(temp, left), AstUtils.Constant(null, left.Type)); } Expression t, f; if (isReverse) { t = temp; f = right; } else { t = right; f = temp; } return(Expression.Condition(condition, t, f)); }
protected override Expression VisitParameter(ParameterExpression node) { return(Expression.Constant(this.fake, node.Type)); }
private bool EqualsParameter(ParameterExpression x, ParameterExpression y) { return(x.Type == y.Type); }
// Helper that is used when re-eval of LHS is safe. private Expression ByValParameterTypeEqual(ParameterExpression value) { Expression getType = Expression.Call(value, typeof(object).GetMethod("GetType")); // In remoting scenarios, obj.GetType() can return an interface. // But there's a if (_typeOperand.IsInterface) { var temp = Expression.Parameter(typeof(Type)); getType = Expression.Block(new[] { temp }, Expression.Assign(temp, getType), temp); } // We use reference equality when comparing to null for correctness // (don't invoke a user defined operator), and reference equality // on types for performance (so the JIT can optimize the IL). return Expression.AndAlso( Expression.ReferenceNotEqual(value, Expression.Constant(null)), Expression.ReferenceEqual( getType, Expression.Constant(_typeOperand.GetNonNullableType(), typeof(Type)) ) ); }
public ParameterReplacer(ParameterExpression paramExpr) { this.ParameterExpression = paramExpr; }