private void Emit(BlockExpression node, EmitAs emitAs) { int count = node.ExpressionCount; // Labels defined immediately in the block are valid for the whole block for(int i = 0; i < count; i++) { Expression e = node.GetExpression(i); var label = e as LabelExpression; if (label != null) { DefineLabel(label.Label); } } EnterScope(node); for (int index = 0; index < count - 1; index++) { EmitExpressionAsVoid(node.GetExpression(index)); } // if the type of Block it means this is not a Comma // so we will force the last expression to emit as void. if (emitAs == EmitAs.Void || node.Type == typeof(void)) { EmitExpressionAsVoid(node.GetExpression(count - 1)); } else { EmitExpression(node.GetExpression(count - 1)); } ExitScope(node); }
private void Emit(BlockExpression node, EmitAs emitAs) { EnterScope(node); int count = node.ExpressionCount; for (int index = 0; index < count - 1; index++) { var e = node.GetExpression(index); if (_emitDebugSymbols) { //No need to emit a clearance if the next expression in the block is also a //DebugInfoExprssion. var debugInfo = e as DebugInfoExpression; if (debugInfo != null && debugInfo.IsClear && node.GetExpression(index + 1) is DebugInfoExpression) { continue; } } EmitExpressionAsVoid(e); } // if the type of Block it means this is not a Comma // so we will force the last expression to emit as void. if (emitAs == EmitAs.Void || node.Type == typeof(void)) { EmitExpressionAsVoid(node.GetExpression(count - 1)); } else { EmitExpressionAsType(node.GetExpression(count - 1), node.Type); } ExitScope(node); }
public FunctionExpression(Token token, string name, List<string> arguments, BlockExpression block) : base(token.FileName, token.Line) { Name = name; Arguments = arguments.AsReadOnly(); Block = block; }
private void Emit(BlockExpression node, CompilationFlags flags) { int count = node.ExpressionCount; if (count == 0) { return; } EnterScope(node); CompilationFlags emitAs = flags & CompilationFlags.EmitAsTypeMask; CompilationFlags tailCall = flags & CompilationFlags.EmitAsTailCallMask; for (int index = 0; index < count - 1; index++) { var e = node.GetExpression(index); var next = node.GetExpression(index + 1); CompilationFlags tailCallFlag; if (tailCall != CompilationFlags.EmitAsNoTail) { var g = next as GotoExpression; if (g != null && (g.Value == null || !Significant(g.Value)) && ReferenceLabel(g.Target).CanReturn) { // Since tail call flags are not passed into EmitTryExpression, CanReturn means the goto will be emitted // as Ret. Therefore we can emit the current expression with tail call. tailCallFlag = CompilationFlags.EmitAsTail; } else { // In the middle of the block. // We may do better here by marking it as Tail if the following expressions are not going to emit any IL. tailCallFlag = CompilationFlags.EmitAsMiddle; } } else { tailCallFlag = CompilationFlags.EmitAsNoTail; } flags = UpdateEmitAsTailCallFlag(flags, tailCallFlag); EmitExpressionAsVoid(e, flags); } // if the type of Block it means this is not a Comma // so we will force the last expression to emit as void. // We don't need EmitAsType flag anymore, should only pass // the EmitTailCall field in flags to emitting the last expression. if (emitAs == CompilationFlags.EmitAsVoidType || node.Type == typeof(void)) { EmitExpressionAsVoid(node.GetExpression(count - 1), tailCall); } else { EmitExpressionAsType(node.GetExpression(count - 1), node.Type, tailCall); } ExitScope(node); }
public ForExpression(Token token, Expression initializer, Expression condition, BlockExpression increment, BlockExpression block) : base(token.FileName, token.Line) { Initializer = initializer; Condition = condition; Increment = increment; Block = block; }
protected virtual BlockExpression UpdateBlockExpression(BlockExpression exp, IEnumerable<Expression> expressions, IEnumerable<ParameterExpression> variables) { if (exp.Expressions != expressions || exp.Variables != variables) { return Expression.Block( variables, expressions ); } return exp; }
public override Expression VisitBlockExpression(BlockExpression blockExpression){ if (blockExpression == null) return null; Block block = blockExpression.Block; if (block != null && block.Statements != null && block.Statements.Count == 1) { ExpressionStatement es = block.Statements[0] as ExpressionStatement; if (es != null) { es.Expression = this.VisitExpression(es.Expression); this.composers.Clear(); this.composers.Add(this.GetComposer(es.Expression)); return (Expression) this.Compose(blockExpression, this.composers); } } return base.VisitBlockExpression(blockExpression); }
private void Emit(BlockExpression node, CompilationFlags flags) { EnterScope(node); CompilationFlags emitAs = flags & CompilationFlags.EmitAsTypeMask; int count = node.ExpressionCount; CompilationFlags tailCall = flags & CompilationFlags.EmitAsTailCallMask; CompilationFlags middleTailCall = tailCall == CompilationFlags.EmitAsNoTail ? CompilationFlags.EmitAsNoTail : CompilationFlags.EmitAsMiddle; for (int index = 0; index < count - 1; index++) { var e = node.GetExpression(index); var next = node.GetExpression(index + 1); if (EmitDebugSymbols) { // No need to emit a clearance if the next expression in the block is also a // DebugInfoExprssion. var debugInfo = e as DebugInfoExpression; if (debugInfo != null && debugInfo.IsClear && next is DebugInfoExpression) { continue; } } // In the middle of the block. // We may do better here by marking it as Tail if the following expressions are not going to emit any IL. var tailCallFlag = middleTailCall; var g = next as GotoExpression; if (g != null && (g.Value == null || !Significant(g.Value))) { var labelInfo = ReferenceLabel(g.Target); if (labelInfo.CanReturn) { // Since tail call flags are not passed into EmitTryExpression, CanReturn means the goto will be emitted // as Ret. Therefore we can emit the current expression with tail call. tailCallFlag = CompilationFlags.EmitAsTail; } } flags = UpdateEmitAsTailCallFlag(flags, tailCallFlag); EmitExpressionAsVoid(e, flags); } // if the type of Block it means this is not a Comma // so we will force the last expression to emit as void. // We don't need EmitAsType flag anymore, should only pass // the EmitTailCall field in flags to emitting the last expression. if (emitAs == CompilationFlags.EmitAsVoidType || node.Type == typeof(void)) { EmitExpressionAsVoid(node.GetExpression(count - 1), tailCall); } else { EmitExpressionAsType(node.GetExpression(count - 1), node.Type, tailCall); } ExitScope(node); }
private void EnterScope(BlockExpression node) { if (node.Variables.Count > 0 && (_scope.MergedScopes == null || !_scope.MergedScopes.Contains(node))) { CompilerScope scope; if (!_tree.Scopes.TryGetValue(node, out scope)) { // // Very often, we want to compile nodes as reductions // rather than as IL, but usually they need to allocate // some IL locals. To support this, we allow emitting a // BlockExpression that was not bound by VariableBinder. // This works as long as the variables are only used // locally -- i.e. not closed over. // // User-created blocks will never hit this case; only our // internally reduced nodes will. // scope = new CompilerScope(node) { NeedsClosure = _scope.NeedsClosure }; } _scope = scope.Enter(this, _scope); Debug.Assert(_scope.Node == node); } }
public override Expression VisitBlockExpression(BlockExpression blockExpression) { if (blockExpression == null) return null; return base.VisitBlockExpression((BlockExpression)blockExpression.Clone()); }
public override Expression VisitBlockExpression(BlockExpression blockExpression) { if (blockExpression == null) return null; // This is either // 1) a call of the form {newLocal = e; &newLocal; }.M(...) // where M.DeclaringType is Struct // We simply serialize e // or // 2) of the form { newLocal = e; AssertNotNull(newLocal); newLocal; } // or // 3) of the form { AssertNotNull(e); e; } // where e is a variable // We simply serialize e // or // 4) of the form { Exception e; <boolean expression involving e> } // This arises from "throws (E e) ensures Q" clauses. Q sits in an ExpressionStatement // with e as a bound variable of the block scope. Block block = blockExpression.Block; if (block == null || block.Statements == null || 3 < block.Statements.Count) return blockExpression; //Debug.Assert(block.Statements.Count == 2 || block.Statements.Count == 3); AssignmentStatement a = block.Statements[0] as AssignmentStatement; if (a != null) { // case (1) or (2) ExpressionStatement es = (ExpressionStatement)block.Statements[1]; Debug.Assert(es.Expression.NodeType == NodeType.AddressOf || es.Expression.NodeType == NodeType.Call); this.Visit(a.Source); } else if (block.Statements.Count == 1) { // case (4) (is a stronger test needed here? // overload the comprehension serialization and compensate after it has been deserialized as a comprehension // NB: this code now lives in two places (here and VisitComprehension)! this._string.Append("{|"); if (0 < block.Scope.Members.Count) { this._string.Append("{"); Field f = block.Scope.Members[0] as Field; // what if there is more than one? this.AddType(f.Type); this._string.Append(","); this.VisitField(f); this._string.Append(",null}"); } this._string.Append(";"); ExpressionStatement es = block.Statements[0] as ExpressionStatement; this.VisitExpression(es.Expression); this._string.Append("|}"); }else { // case (3) ExpressionStatement es = (ExpressionStatement)block.Statements[1]; this.Visit(es.Expression); } return blockExpression; }
public DoWhileExpression(Token token, BlockExpression block, Expression condition) : base(token.FileName, token.Line) { Block = block; Condition = condition; }
public Expression <SetDelegate <T, TValue> > GetExpression <TValue>() { var xType = typeof(TValue); var tmp = Expression.Variable(typeof(TProp), "tmp"); var input = Expression.Parameter(typeof(TValue), "input"); var instance = Expression.Parameter(typeof(T).MakeByRefType(), "instance"); var provider = Expression.Parameter(typeof(IFormatProvider), "provider"); var memberExpression = Expression.MakeMemberAccess( instance, ModelInfo.GetOptimalMemberInfo()); var invoke = Expression.Invoke( Expression.Constant(ConvertTo <TValue, TProp> .From), input, provider); BlockExpression block = null; if (ModelInfo.Type == xType) { block = Expression.Block(Expression.Assign(memberExpression, input)); } else if (ModelInfo.Type == typeof(object) && !xType.IsNullable()) { block = Expression.Block(Expression.Assign( memberExpression, Expression.Convert(input, typeof(object)))); } else if (ModelInfo.Type == typeof(object) && xType.IsNullable()) { var value = Expression.Property(input, "Value"); var ifThenElse = Expression.IfThenElse( Expression.Property(input, "HasValue"), Expression.Assign(memberExpression, Expression.Convert(value, typeof(object))), Expression.Assign(memberExpression, Expression.Default(ModelInfo.Type))); block = Expression.Block(ifThenElse); } else if (xType.IsNullable() && Nullable.GetUnderlyingType(xType) == ModelInfo.Type) { var value = Expression.Property(input, "Value"); var ifThenElse = Expression.IfThenElse( Expression.Property(input, "HasValue"), Expression.Assign(memberExpression, Expression.Convert(value, ModelInfo.Type)), Expression.Assign(memberExpression, Expression.Default(ModelInfo.Type))); block = Expression.Block(ifThenElse); } else if (ModelInfo.Type.IsNullable() && Nullable.GetUnderlyingType(ModelInfo.Type) == xType) { block = Expression.Block(Expression.Assign( memberExpression, Expression.Convert(input, ModelInfo.Type))); } else if (xType == typeof(object)) { var ifThenElse = Expression.IfThenElse( Expression.TypeEqual(input, ModelInfo.Type), Expression.Assign(memberExpression, Expression.Convert(input, ModelInfo.Type)), Expression.Block( new[] { tmp }, Expression.Assign(tmp, invoke), Expression.Assign(memberExpression, tmp))); block = Expression.Block(ifThenElse); } else if (xType != ModelInfo.Type) { block = Expression.Block( new[] { tmp }, Expression.Assign(tmp, invoke), Expression.Assign(memberExpression, tmp)); } return(Expression.Lambda <SetDelegate <T, TValue> >( block, instance, input, provider)); }
public virtual Expression VisitBlockExpression(BlockExpression blockExpression){ if (blockExpression == null) return null; blockExpression.Block = this.VisitBlock(blockExpression.Block); return blockExpression; }
private Expression ReplaceIn(BlockExpression block) { return(ReplaceIn( block, b => b.Update(b.Variables.Select(ReplaceIn), b.Expressions.Select(Replace)))); }
private static BlockExpression SetChildren(ReadOnlySpan <Expression> newChildren, BlockExpression b) => b.Update(b.Variables, newChildren.ToArray());
/// <summary> /// To the result tree member expression /// </summary> /// <param name="rule">The rule.</param> /// <param name="childRuleResults">The child rule results.</param> /// <param name="isSuccessExp">The is success exp.</param> /// <param name="childRuleResultsblockexpr">The child rule results block expression.</param> /// <returns></returns> internal static MemberInitExpression ToResultTree(Rule rule, IEnumerable <MemberInitExpression> childRuleResults, BinaryExpression isSuccessExp, IEnumerable <ParameterExpression> typeParamExpressions, BlockExpression childRuleResultsblockexpr, string exceptionMessage = "") { var createdType = typeof(RuleResultTree); var ctor = Expression.New(createdType); var ruleProp = createdType.GetProperty(nameof(RuleResultTree.Rule)); var isSuccessProp = createdType.GetProperty(nameof(RuleResultTree.IsSuccess)); var childResultProp = createdType.GetProperty(nameof(RuleResultTree.ChildResults)); var inputProp = createdType.GetProperty(nameof(RuleResultTree.Input)); var exceptionProp = createdType.GetProperty(nameof(RuleResultTree.ExceptionMessage)); var rulePropBinding = Expression.Bind(ruleProp, Expression.Constant(rule)); var isSuccessPropBinding = Expression.Bind(isSuccessProp, isSuccessExp); var inputBinding = Expression.Bind(inputProp, typeParamExpressions.FirstOrDefault()); var exceptionBinding = Expression.Bind(exceptionProp, Expression.Constant(exceptionMessage)); MemberInitExpression memberInit; if (childRuleResults != null) { var ruleResultTreeArr = Expression.NewArrayInit(typeof(RuleResultTree), childRuleResults); var childResultPropBinding = Expression.Bind(childResultProp, ruleResultTreeArr); memberInit = Expression.MemberInit(ctor, new[] { rulePropBinding, isSuccessPropBinding, childResultPropBinding, inputBinding, exceptionBinding }); } else if (childRuleResultsblockexpr != null) { var childResultPropBinding = Expression.Bind(childResultProp, childRuleResultsblockexpr); memberInit = Expression.MemberInit(ctor, new[] { rulePropBinding, isSuccessPropBinding, childResultPropBinding, inputBinding, exceptionBinding }); } else { memberInit = Expression.MemberInit(ctor, new[] { rulePropBinding, isSuccessPropBinding, inputBinding, exceptionBinding }); } return(memberInit); }
protected override Expression VisitBlock(BlockExpression node) { Stop(); return(base.VisitBlock(node)); }
private static void GetChildren(Span <Expression> children, BlockExpression b) { Copy(b.Expressions, children); }
/// <summary> /// Visits the children of <see cref="System.Linq.Expressions.BlockExpression"/>. /// </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 VisitBlock(BlockExpression node) { throw new NotSupportedException(string.Format(Resources.EX_PROCESS_NODE_NOT_SUPPORT, node.GetType().Name)); }
protected override Expression VisitBlock(BlockExpression node) { this.expressions.Add(node); return(base.VisitBlock(node)); }
protected override Expression VisitBlock(BlockExpression node) { Console.WriteLine($"call {MethodBase.GetCurrentMethod().Name} : {node}"); return(base.VisitBlock(node)); }
public virtual Expression ImplicitCoercion(Expression source, TypeNode targetType, TypeViewer typeViewer){ TypeNode originalTargetType = targetType; if (targetType == null || targetType.Name == Looker.NotFound) return source; if (source == null) return null; //HS D if (source is Hole) { source.Type = targetType; return source; } //HS D if (source is LambdaHole) { if (targetType == SystemTypes.Boolean) source = new LambdaHole(source, new Literal(0), NodeType.Ge, source.SourceContext); source.Type = targetType; return source; } Literal sourceLit = source as Literal; if (sourceLit != null && sourceLit.Value is TypeNode){ this.HandleError(source, Error.TypeInVariableContext, this.GetTypeName((TypeNode)sourceLit.Value), "class", "variable"); return null; } //Ignore parentheses if (source.NodeType == NodeType.Parentheses){ UnaryExpression uex = (UnaryExpression)source; uex.Operand = this.ImplicitCoercion(uex.Operand, targetType, typeViewer); if (uex.Operand == null) return null; uex.Type = uex.Operand.Type; return uex; } bool targetIsNonNullType = this.IsNonNullType(targetType); targetType = TypeNode.StripModifier(targetType, SystemTypes.NonNullType); targetType = TypeNode.StripModifier(targetType, SystemTypes.NullableType); //TODO: handle SkipCheck and EnforceCheck //Special case for closure expressions if (source.NodeType == NodeType.AnonymousNestedFunction) return this.CoerceAnonymousNestedFunction((AnonymousNestedFunction)source, targetType, false, typeViewer); TypeNode sourceType = source.Type; if (sourceType == null) sourceType = SystemTypes.Object; bool sourceIsNonNullType = this.IsNonNullType(source.Type); sourceType = TypeNode.StripModifier(sourceType, SystemTypes.NonNullType); sourceType = TypeNode.StripModifier(sourceType, SystemTypes.NullableType); if (sourceType == SystemTypes.String && !sourceIsNonNullType && source is Literal) sourceIsNonNullType = ((Literal)source).Value != null; if (this.currentParameter != null && targetType is Reference){ UnaryExpression uex = source as UnaryExpression; if (uex != null){ if (sourceIsNonNullType && !targetIsNonNullType){ string ttypeName = this.GetTypeName(targetType); string stypeName = this.GetTypeName(source.Type); this.HandleError(source, Error.NoImplicitCoercion, stypeName, ttypeName); return null; } if (!sourceIsNonNullType && targetIsNonNullType){ string ttypeName = this.GetTypeName(targetType); string stypeName = this.GetTypeName(source.Type); this.HandleError(source, Error.NoImplicitCoercion, stypeName, ttypeName); return null; } if (uex.NodeType == NodeType.OutAddress){ if ((this.currentParameter.Flags & ParameterFlags.Out) == 0){ this.currentParameter.Flags |= ParameterFlags.Out; string stypeName = this.GetTypeName(sourceType); this.currentParameter.Flags &= ~ParameterFlags.Out; this.HandleError(source, Error.NoImplicitCoercion, stypeName, this.GetTypeName(targetType)); return null; } }else if (uex.NodeType == NodeType.RefAddress){ if ((this.currentParameter.Flags & ParameterFlags.Out) != 0){ this.currentParameter.Flags &= ~ParameterFlags.Out; string stypeName = this.GetTypeName(sourceType); this.currentParameter.Flags |= ParameterFlags.Out; this.HandleError(source, Error.NoImplicitCoercion, stypeName, this.GetTypeName(targetType)); return null; } } } } Expression result = this.StandardImplicitCoercion(source, sourceIsNonNullType, sourceType, targetIsNonNullType, targetType, originalTargetType, typeViewer); if (result != null) return result; Method coercion = this.UserDefinedImplicitCoercionMethod(source, sourceType, targetType, true, typeViewer); if (coercion != null){ if (this.IsNullableType(targetType) && this.IsNullableType(sourceType) && !this.IsNullableType(coercion.Parameters[0].Type)) return this.CoerceWithLiftedCoercion(source, sourceType, targetType, coercion, false, typeViewer); ExpressionList args = new ExpressionList(1); args.Add(this.ImplicitCoercion(source, coercion.Parameters[0].Type, typeViewer)); return this.ImplicitCoercion(new MethodCall(new MemberBinding(null, coercion), args, NodeType.Call, coercion.ReturnType, source.SourceContext), targetType, typeViewer); } if (sourceType == SystemTypes.Type && source is Literal) this.HandleError(source, Error.TypeInVariableContext, this.GetTypeName((TypeNode)((Literal)source).Value), "class", "variable"); else if (this.IsNullableType(sourceType) && this.IsNullableType(targetType) && this.ImplicitCoercionFromTo(this.RemoveNullableWrapper(sourceType), this.RemoveNullableWrapper(targetType))) { TypeNode usType = this.RemoveNullableWrapper(sourceType); TypeNode utType = this.RemoveNullableWrapper(targetType); Local tempSrc = new Local(sourceType); Local tempTar = new Local(targetType); StatementList statements = new StatementList(); BlockExpression result1 = new BlockExpression(new Block(statements)); statements.Add(new AssignmentStatement(tempSrc, source)); Method hasValue = sourceType.GetMethod(StandardIds.getHasValue); Method getValueOrDefault = sourceType.GetMethod(StandardIds.GetValueOrDefault); Method ctor = targetType.GetMethod(StandardIds.Ctor, utType); Block pushValue = new Block(); Block done = new Block(); Expression tempHasValue = new MethodCall(new MemberBinding(new UnaryExpression(tempSrc, NodeType.AddressOf), hasValue), null); tempHasValue.Type = SystemTypes.Boolean; statements.Add(new Branch(tempHasValue, pushValue)); statements.Add(new AssignmentStatement(new AddressDereference(new UnaryExpression(tempTar, NodeType.AddressOf), targetType), new Literal(null, CoreSystemTypes.Object))); statements.Add(new Branch(null, done)); statements.Add(pushValue); Expression value = new MethodCall(new MemberBinding(new UnaryExpression(tempSrc, NodeType.AddressOf), getValueOrDefault), null); value.Type = usType; value = this.ImplicitCoercion(value, utType); Construct cons = new Construct(new MemberBinding(null, ctor), new ExpressionList(value)); result1.Type = ctor.DeclaringType; statements.Add(new AssignmentStatement(tempTar, cons)); statements.Add(done); statements.Add(new ExpressionStatement(tempTar)); return result1; }else this.HandleError(source, Error.NoImplicitCoercion, this.GetTypeName(sourceType), this.GetTypeName(originalTargetType)); return null; }
private static int CountChildren(BlockExpression b) => b.Expressions.Count;
public virtual Expression CoerceTypeUnionToObject(Expression source, TypeViewer typeViewer){ TypeUnion sourceType = (TypeUnion)source.Type; Method getValue = TypeViewer.GetTypeView(typeViewer, sourceType).GetMethod(StandardIds.GetValue); Local temp = new Local(Identifier.Empty, sourceType); Expression tempAddr = new UnaryExpression(temp, NodeType.AddressOf); StatementList statements = new StatementList(2); statements.Add(new AssignmentStatement(temp, source)); statements.Add(new ExpressionStatement(new MethodCall(new MemberBinding(tempAddr, getValue), null))); BlockExpression result = new BlockExpression(new Block(statements)); result.Type = SystemTypes.Object; return result; }
} // ctor protected override Expression VisitBlock(BlockExpression node) { return(base.VisitBlock(Expression.Block(node.Type, node.Variables, ReduceDebugExpressions(node.Expressions)))); } // func VisitBlock
protected override Expression VisitBlock(BlockExpression node) { return(Expression.Block( node.Variables, node.Expressions.Select(Visit))); }
public AnonymousFunctionExpression(TupleDeclarationExpression arguments, TypeName returnType, BlockExpression body) { this.arguments = arguments; this.returnType = returnType; this.body = body; }
public BlockExpressionProxy(BlockExpression node) { _node = node; }
public override void OnBlockExpression(BlockExpression node) { }
bool IEvaluatableExpressionFilter.IsEvaluatableBlock(BlockExpression node) => true;
public static void part1() { //var aa = new MyQueryable<Student>(); //var bb = aa.Where(s => s.Name == "李军"); //var cc = bb.Where(s => s.Age > 24); //var dd = cc.AsEnumerable(); //var ee = dd.ToList(); LabelTarget labelTarget = Expression.Label(); ParameterExpression loopIndex = Expression.Parameter(typeof(int), "index"); Expression.Assign(loopIndex, Expression.Constant(1)); BlockExpression block = Expression.Block( new[] { loopIndex }, Expression.Assign(loopIndex, Expression.Constant(1)), Expression.Loop( Expression.IfThenElse( Expression.LessThanOrEqual(loopIndex, Expression.Constant(10)), Expression.Block( Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), Expression.Constant("hello")), Expression.PostIncrementAssign(loopIndex) ), Expression.Break(labelTarget) ), labelTarget)); Expression <Action> lambda = Expression.Lambda <Action>(block); lambda.Compile()(); Expression <Func <int, int> > func = x => x + 1; TypeBinaryExpression type = Expression.TypeIs(Expression.Constant("pro"), typeof(int)); ParameterExpression arr = Expression.Parameter(typeof(int[]), "arr"); ParameterExpression index = Expression.Parameter(typeof(int), "index"); ParameterExpression value = Expression.Parameter(typeof(int), "value"); Expression arrAccess = Expression.ArrayAccess(arr, index); Expression <Func <int[], int, int, int> > lambdaExpr = Expression.Lambda <Func <int[], int, int, int> > ( Expression.Assign(arrAccess, Expression.Add(arrAccess, value)), arr, index, value ); Console.WriteLine(arrAccess.ToString()); Console.WriteLine(lambdaExpr.ToString()); Console.WriteLine(lambdaExpr.Compile()(new int[] { 1, 2, 3 }, 0, 5)); Expression <Func <int, int, bool> > largeSumTest = (num1, num2) => (num1 + num2) > 1000; InvocationExpression invocation = Expression.Invoke( largeSumTest, Expression.Constant(100), Expression.Constant(100)); //ParameterExpression student = Expression.Parameter(typeof(Student)); //var expr = Expression.Property(student, "Name"); //var where = Expression.Equal(expr, Expression.Constant("小明")); //var orderExpr = Expression.Lambda<Func<Student, bool>>(where, student); //var orderedStudentArrary = StudentArrary.Where(orderExpr.Compile()); var modules = new List <Module> { new Module { Name = "01" }, new Module { Name = "02" }, new Module { Name = "03" }, new Module { Name = "04", IsDeleted = true }, new Module { Name = "05" }, }; ParameterExpression Module = Expression.Parameter(typeof(Module)); var proExpr = Expression.Property(Module, "Name"); var condition = Expression.Equal(proExpr, Expression.Constant("02")); var proExprDel = Expression.Property(Module, "IsDeleted"); var deleteCondition = Expression.Equal(proExprDel, Expression.Constant(false)); var predicateExp = Expression.AndAlso(condition, deleteCondition); var predicate = Expression.Lambda <Func <Module, bool> >(predicateExp, Module).Compile(); var filter = modules.Where(predicate); }
BlockExpression Convert(BlockExpression expr) { return(expr.Update(Process(expr.Variables), Process(expr.Expressions))); }
public override void LeaveBlockExpression(BlockExpression node) { OnExpression(node); }
public virtual Expression VisitBlockExpression(BlockExpression blockExpression1, BlockExpression blockExpression2) { if (blockExpression1 == null) return null; if (blockExpression2 == null) blockExpression1.Block = this.VisitBlock(blockExpression1.Block, null); else blockExpression1.Block = this.VisitBlock(blockExpression1.Block, blockExpression2.Block); return blockExpression1; }
public override Expression VisitBlockExpression(BlockExpression blockExpression) { throw new ApplicationException("unimplemented"); }
public Branch(Expression condition, BlockExpression block) { Condition = condition; Block = block; }
private static void AssertBlockIsOptimized(BlockExpression expr, IReadOnlyList<Expression> args) { var n = args.Count; var updated = Update(expr); var visited = Visit(expr); foreach (var node in new[] { expr, updated, visited }) { AssertBlock(n, node); Assert.Equal(n, node.Expressions.Count); if (node != visited) // our visitor clones argument nodes { for (var i = 0; i < n; i++) { Assert.Same(args[i], node.Expressions[i]); } } } }
protected override Expression VisitBlock(BlockExpression node) { var exprs = node.Expressions.SelectMany(e => new Expression[] { _log(Expression.Constant("S" + _n++)), Visit(e) }).ToList(); return node.Update(node.Variables, exprs); }
private static BlockExpression Visit(BlockExpression node) { // Tests dispatch of ExpressionVisitor into Rewrite method which calls Expression.Block factories. return (BlockExpression)new Visitor().Visit(node); }
protected virtual Expression StandardImplicitCoercion(Expression source, bool sourceIsNonNullType, TypeNode sourceType, bool targetIsNonNullType, TypeNode targetType, TypeNode originalTargetType, TypeViewer typeViewer){ if (Literal.IsNullLiteral(source)) { if (this.IsNullableType(targetType)) { Local temp = new Local(targetType); StatementList statements = new StatementList(); BlockExpression result = new BlockExpression(new Block(statements)); statements.Add(new AssignmentStatement(new AddressDereference(new UnaryExpression(temp, NodeType.AddressOf), targetType), new Literal(null, CoreSystemTypes.Object))); statements.Add(new ExpressionStatement(temp)); return result; } if (targetType.IsTemplateParameter && !targetType.IsReferenceType) { // Check for reference constraint this.HandleError(source, Error.TypeVarCantBeNull, targetType.Name.Name); return new Local(targetType); } } //Identity coercion if (sourceType == targetType && (!targetIsNonNullType || (targetIsNonNullType == sourceIsNonNullType))) return source; ITypeParameter stp = sourceType as ITypeParameter; ITypeParameter ttp = targetType as ITypeParameter; if (stp != null && ttp != null && stp.ParameterListIndex == ttp.ParameterListIndex && stp.DeclaringMember == ttp.DeclaringMember && (!targetIsNonNullType || (targetIsNonNullType == sourceIsNonNullType))) return source; if (source is This && targetType != null && sourceType == targetType.Template && targetType.IsNotFullySpecialized) //TODO: add check for sourceType.TemplateParameters == targetType.TemplateArguments return source; //Dereference source Reference sr = sourceType as Reference; if (sr != null){ sourceType = sr.ElementType; Pointer pType = targetType as Pointer; if (pType != null && this.StandardImplicitCoercionFromTo(null, sourceType, pType.ElementType, typeViewer)) return source; else if (pType != null && pType.ElementType == SystemTypes.Void) return source; bool sourceIsThis = source is This; source = new AddressDereference(source, sourceType, source.SourceContext); source.Type = sourceType; sourceIsNonNullType = this.IsNonNullType(sourceType); sourceType = TypeNode.StripModifier(sourceType, SystemTypes.NonNullType); //Special case for coercion of this in template class if (sourceIsThis && targetType != null && sourceType == targetType.Template && targetType.IsNotFullySpecialized) //TODO: add check for sourceType.TemplateParameters == targetType.TemplateArguments return source; } //Identity coercion after dereference if (sourceType == targetType && (!targetIsNonNullType || (targetIsNonNullType == sourceIsNonNullType))) return source; //Special case for null literal if (Literal.IsNullLiteral(source)){ if (targetIsNonNullType) return ImplicitNonNullCoercion(this.ErrorHandler, source, originalTargetType); if (targetType is ITypeParameter && this.useGenerics) return new BinaryExpression(source, new Literal(targetType, SystemTypes.Type), NodeType.UnboxAny); if (!targetType.IsValueType || targetType.Template == SystemTypes.GenericBoxed) return new Literal(null, targetType, source.SourceContext); if (this.IsNullableType(targetType)) return new Local(StandardIds.NewObj, targetType, source.SourceContext); TypeAlias tAlias = targetType as TypeAlias; if (tAlias != null){ if (tAlias.RequireExplicitCoercionFromUnderlyingType) return null; source = this.ImplicitCoercion(source, tAlias.AliasedType, typeViewer); if (source == null) return null; Method coercion = this.UserDefinedImplicitCoercionMethod(source, tAlias.AliasedType, targetType, false, typeViewer); if (coercion != null){ ExpressionList args = new ExpressionList(this.ImplicitCoercion(source, coercion.Parameters[0].Type, typeViewer)); return new MethodCall(new MemberBinding(null, coercion), args, NodeType.Call, coercion.ReturnType); } }else{ Method coercion = this.UserDefinedImplicitCoercionMethod(source, source.Type, targetType, true, typeViewer); if (coercion != null){ ExpressionList args = new ExpressionList(this.ImplicitCoercion(source, coercion.Parameters[0].Type, typeViewer)); return new MethodCall(new MemberBinding(null, coercion), args, NodeType.Call, coercion.ReturnType); } } this.HandleError(source, Error.CannotCoerceNullToValueType, this.GetTypeName(targetType)); return new Local(targetType); } //Special case for string literal if (source.NodeType == NodeType.Literal && sourceType == SystemTypes.String && (targetType.Template == SystemTypes.GenericNonNull || targetType.Template == SystemTypes.GenericInvariant) && this.GetStreamElementType(targetType, typeViewer) == SystemTypes.String) return this.ExplicitCoercion(source, targetType, typeViewer); //Implicit numeric coercions + implicit enumeration coercions + implicit constant expression coercions if (sourceType.IsPrimitive && sourceType != SystemTypes.String && (targetType.IsPrimitive || targetType == SystemTypes.Decimal || targetType is EnumNode)){ Expression primitiveCoercion = this.ImplicitPrimitiveCoercion(source, sourceType, targetType, typeViewer); if (primitiveCoercion != null) return primitiveCoercion; } //Implicit coercion from string literal to numbers or eums if (this.allowStringLiteralToOtherPrimitiveCoercion && sourceType == SystemTypes.String && (targetType.IsPrimitive || targetType == SystemTypes.Decimal || targetType is EnumNode)){ Expression primitiveCoercion = this.ImplicitPrimitiveCoercion(source, sourceType, targetType, typeViewer); if (primitiveCoercion != null) return primitiveCoercion; } //Implicit reference coercions if (TypeViewer.GetTypeView(typeViewer, sourceType).IsAssignableTo(targetType)){ if (targetIsNonNullType && !(sourceIsNonNullType) && !sourceType.IsValueType) { //Handling for non null types return ImplicitNonNullCoercion(this.ErrorHandler, source, originalTargetType); }else if (sourceType.IsValueType && !targetType.IsValueType){ if (sourceType.NodeType == NodeType.TypeUnion){ Debug.Assert(targetType == SystemTypes.Object); return this.CoerceTypeUnionToObject(source, typeViewer); } if (sourceType is TupleType){ if (targetType == SystemTypes.Object) return this.TupleCoercion(source, sourceType, targetType, false, typeViewer); }else if (targetType.Template != SystemTypes.GenericIEnumerable && this.GetStreamElementType(sourceType, typeViewer) != sourceType) return this.ExplicitCoercion(this.CoerceStreamToObject(source, sourceType, typeViewer), targetType, typeViewer); Expression e = new BinaryExpression(source, new MemberBinding(null, sourceType), NodeType.Box, targetType, source.SourceContext); e.Type = targetType; return e; }else if (this.useGenerics && (sourceType is TypeParameter || sourceType is ClassParameter)){ source = new BinaryExpression(source, new MemberBinding(null, sourceType), NodeType.Box, sourceType); if (targetType == SystemTypes.Object) return source; return new BinaryExpression(source, new MemberBinding(null, targetType), NodeType.UnboxAny, targetType); } else if (this.useGenerics && sourceType is ArrayType) { ArrayType sat = (ArrayType)sourceType; while (sat.ElementType is ArrayType) sat = (ArrayType)sat.ElementType; if (sat.ElementType is ITypeParameter) return new BinaryExpression(source, new MemberBinding(null, targetType), NodeType.Castclass, targetType, source.SourceContext); return source; }else return source; } //Special case for delegates if (targetType is DelegateNode) return this.CoerceToDelegate(source, sourceType, (DelegateNode)targetType, false, typeViewer); //Special case for type union to common base type if (sourceType.NodeType == NodeType.TypeUnion) return this.CoerceFromTypeUnion(source, (TypeUnion)sourceType, targetType, false, originalTargetType, typeViewer); //Special case for Type intersection target type if (targetType.NodeType == NodeType.TypeIntersection) return this.CoerceToTypeIntersection(source, sourceType, (TypeIntersection)targetType, false, typeViewer); //Special cases for typed streams Expression streamCoercion = this.StreamCoercion(source, sourceType, targetType, false, originalTargetType, typeViewer); if (streamCoercion != null) return streamCoercion; //Implicit tuple coercions return this.TupleCoercion(source, sourceType, targetType, false, typeViewer); }
public ClosureSignatureInferrer(BlockExpression closure) { _closure = closure; InitializeInputTypes(); }
// Move off the main stack private Expression BuildScopedExpression(ServiceCallSite callSite) { ConstantExpression callSiteExpression = Expression.Constant( callSite, typeof(ServiceCallSite)); // We want to directly use the callsite value if it's set and the scope is the root scope. // We've already called into the RuntimeResolver and pre-computed any singletons or root scope // Avoid the compilation for singletons (or promoted singletons) MethodCallExpression resolveRootScopeExpression = Expression.Call( CallSiteRuntimeResolverInstanceExpression, ServiceLookupHelpers.ResolveCallSiteAndScopeMethodInfo, callSiteExpression, ScopeParameter); ConstantExpression keyExpression = Expression.Constant( callSite.Cache.Key, typeof(ServiceCacheKey)); ParameterExpression resolvedVariable = Expression.Variable(typeof(object), "resolved"); ParameterExpression resolvedServices = ResolvedServices; MethodCallExpression tryGetValueExpression = Expression.Call( resolvedServices, ServiceLookupHelpers.TryGetValueMethodInfo, keyExpression, resolvedVariable); Expression captureDisposible = TryCaptureDisposable(callSite, ScopeParameter, VisitCallSiteMain(callSite, null)); BinaryExpression assignExpression = Expression.Assign( resolvedVariable, captureDisposible); MethodCallExpression addValueExpression = Expression.Call( resolvedServices, ServiceLookupHelpers.AddMethodInfo, keyExpression, resolvedVariable); BlockExpression blockExpression = Expression.Block( typeof(object), new[] { resolvedVariable }, Expression.IfThen( Expression.Not(tryGetValueExpression), Expression.Block( assignExpression, addValueExpression)), resolvedVariable); // The C# compiler would copy the lock object to guard against mutation. // We don't, since we know the lock object is readonly. ParameterExpression lockWasTaken = Expression.Variable(typeof(bool), "lockWasTaken"); ParameterExpression sync = Sync; MethodCallExpression monitorEnter = Expression.Call(ServiceLookupHelpers.MonitorEnterMethodInfo, sync, lockWasTaken); MethodCallExpression monitorExit = Expression.Call(ServiceLookupHelpers.MonitorExitMethodInfo, sync); BlockExpression tryBody = Expression.Block(monitorEnter, blockExpression); ConditionalExpression finallyBody = Expression.IfThen(lockWasTaken, monitorExit); return(Expression.Condition( Expression.Property( ScopeParameter, typeof(ServiceProviderEngineScope) .GetProperty(nameof(ServiceProviderEngineScope.IsRootScope), BindingFlags.Instance | BindingFlags.Public)), resolveRootScopeExpression, Expression.Block( typeof(object), new[] { lockWasTaken }, Expression.TryFinally(tryBody, finallyBody)) )); }
public override Expression Reduce() { LabelTarget forLabel = Label("<ironsilver_for>"); VariableExpression forReturn = null; LeftHandValueExpression forReturnLh = null; bool useReturn = true; if (Body.Type == typeof (void)) { useReturn = false; } else { forReturn = Variable(Constant("<ironsilver_for_return>")); forReturnLh = LeftHandValue(forReturn); forReturn.Scope = ((AstExpression) Body).Scope; forReturnLh.Scope = ((AstExpression) Body).Scope; } VariableExpression forTest = Variable(Constant("<ironsilver_for_test>")); LeftHandValueExpression forTestLh = LeftHandValue(forTest); forTest.Scope = ((AstExpression) Body).Scope; forTestLh.Scope = ((AstExpression) Body).Scope; var realBody = new List<Expression> { Init, Label(forLabel), }; AssignmentExpression testAssign = Assign(forTestLh, Test); realBody.Add(Label(SilverParser.RetryTarget)); testAssign.Scope = (Body as AstExpression).Scope; realBody.Add(testAssign); IfExpression testIf; if (useReturn) { AssignmentExpression returnAssign = Assign(forReturnLh, Body); returnAssign.Scope = (Body as AstExpression).Scope; testIf = IfThen(forTest, returnAssign); } else { testIf = IfThen(forTest, Body); } testIf.Scope = ((AstExpression) Body).Scope; realBody.Add(testIf); realBody.Add(Label(SilverParser.ContinueTarget)); realBody.Add(Step); realBody.Add(IfThen(forTest, Goto(forLabel))); realBody.Add(Label(SilverParser.BreakTarget)); if (useReturn) { realBody.Add(forReturn); } var block = new BlockExpression(realBody) {Scope = (Body as AstExpression).Scope}; return Convert(block, Type); }
private void __limitCompare_Init() { ParameterExpression pLimitMin = Expression.Parameter(typeof(DateTime)); ParameterExpression pLimitMax = Expression.Parameter(typeof(DateTime)); ParameterExpression pDate = Expression.Parameter(typeof(DateTime)); ParameterExpression pResult = Expression.Parameter(typeof(DateTime)); BlockExpression block = null; Expression eComparisonGreater = Expression.IfThenElse( Expression.GreaterThanOrEqual(pDate, pLimitMin), Expression.Assign(pResult, pDate), Expression.Assign(pResult, pLimitMin) ); Expression eComparisonLess = Expression.IfThenElse( Expression.LessThanOrEqual(pDate, pLimitMax), Expression.Assign(pResult, pDate), Expression.Assign(pResult, pLimitMax) ); Expression eMinMax = Expression.IfThenElse( Expression.GreaterThan(pDate, pLimitMax), Expression.Assign(pResult, pLimitMax), Expression.Assign(pResult, pLimitMin) ); Expression eComparisonRange = Expression.IfThenElse( Expression.AndAlso( Expression.GreaterThanOrEqual(pDate, pLimitMin), Expression.LessThanOrEqual(pDate, pLimitMax) ), Expression.Assign(pResult, pDate), eMinMax ); switch (limit) { case e_dot_Limit.inDate: __setLR(true, false); block = Expression.Block( typeof(DateTime), new[] { pResult }, Expression.Assign(pResult, pLimitMin), pResult ); break; case e_dot_Limit.notEarlier: __setLR(true, false); block = Expression.Block( typeof(DateTime), new[] { pResult }, eComparisonGreater, pResult ); break; case e_dot_Limit.notLater: __setLR(false, true); block = Expression.Block( typeof(DateTime), new[] { pResult }, eComparisonLess, pResult ); break; /*case e_dot_Limit.Range: * __setLR(true, true); * block = Expression.Block( * typeof(DateTime), * new[] { pResult }, * eComparisonRange, * pResult * ); * break;*/ /*case e_dot_Limit.None: * default: * __setLR(false, false); * block = Expression.Block( * typeof(DateTime), * new[] { pResult }, * Expression.Assign(pResult, pDate), * pResult * ); * break;*/ } __limitCMP = null; __limitCMP = Expression.Lambda <Func <DateTime, DateTime, DateTime, DateTime> >(block, pLimitMin, pLimitMax, pDate).Compile(); }
/// <summary> /// Creates a mapper Func for a POCO. /// </summary> private Func <Row, T> CreateMapperForPoco <T>(RowSet rows, PocoData pocoData) { // We're going to store the method body expressions in a list since we need to use some looping to generate it ICollection <Expression> methodBodyExpressions = new LinkedList <Expression>(); // The input parameter for our Func<Row, T>, a C* Row ParameterExpression row = Expression.Parameter(CassandraRowType, "row"); // T poco = new T(); var poco = Expression.Variable(pocoData.PocoType, "poco"); if (pocoData.PocoType.GetTypeInfo().GetConstructor(Type.EmptyTypes) != null) { //It has default constructor methodBodyExpressions.Add(Expression.Assign(poco, Expression.New(pocoData.PocoType))); } else { var constructor = pocoData.PocoType.GetTypeInfo().GetConstructors().FirstOrDefault(c => c.GetParameters().Length == rows.Columns.Length); if (constructor == null) { throw new ArgumentException( string.Format("RowSet columns length is {0} but type {1} does not contain a constructor with the same amount of parameters", rows.Columns.Length, pocoData.PocoType)); } var parameterInfos = constructor.GetParameters(); var parameterExpressions = new List <Expression>(); for (var i = 0; i < rows.Columns.Length; i++) { var c = rows.Columns[i]; var param = parameterInfos[i]; var getValueT = GetExpressionToGetColumnValueFromRow(row, c, param.ParameterType); parameterExpressions.Add(getValueT); } methodBodyExpressions.Add(Expression.Assign(poco, Expression.New(constructor, parameterExpressions))); } // Keep track of any variables we need in the method body, starting with the poco variable var methodBodyVariables = new List <ParameterExpression> { poco }; foreach (var dbColumn in rows.Columns) { // Try to find a corresponding column on the POCO and if not found, don't map that column from the RowSet PocoColumn pocoColumn; if (pocoData.Columns.TryGetItem(dbColumn.Name, out pocoColumn) == false) { continue; } // Figure out if we're going to need to do any casting/conversion when we call Row.GetValue<T>(columnIndex) Expression getColumnValue = GetExpressionToGetColumnValueFromRow(row, dbColumn, pocoColumn.MemberInfoType); // poco.SomeFieldOrProp = ... getColumnValue call ... BinaryExpression getValueAndAssign = Expression.Assign(Expression.MakeMemberAccess(poco, pocoColumn.MemberInfo), getColumnValue); // Start with an expression that does nothing if the row is null Expression ifRowValueIsNull = Expression.Empty(); // Cassandra will return null for empty collections, so make an effort to populate collection properties on the POCO with // empty collections instead of null in those cases Expression createEmptyCollection; if (TryGetCreateEmptyCollectionExpression(dbColumn, pocoColumn.MemberInfoType, out createEmptyCollection)) { // poco.SomeFieldOrProp = ... createEmptyCollection ... ifRowValueIsNull = Expression.Assign(Expression.MakeMemberAccess(poco, pocoColumn.MemberInfo), createEmptyCollection); } var columnIndex = Expression.Constant(dbColumn.Index, IntType); //Expression equivalent to // if (row.IsNull(columnIndex) == false) => getValueAndAssign ... // else => ifRowIsNull ... methodBodyExpressions.Add(Expression.IfThenElse(Expression.IsFalse(Expression.Call(row, IsNullMethod, columnIndex)), getValueAndAssign, ifRowValueIsNull)); } // The last expression in the method body is the return value, so put our new POCO at the end methodBodyExpressions.Add(poco); // Create a block expression for the method body expressions BlockExpression methodBody = Expression.Block(methodBodyVariables, methodBodyExpressions); // Return compiled expression return(Expression.Lambda <Func <Row, T> >(methodBody, row).Compile()); }
public virtual void VisitBlockExpression(BlockExpression blockExpression) { if (blockExpression == null) return; this.VisitBlock(blockExpression.Block); }
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount) { result = null; replacedStatementsCount = 0; if (!this.TryGetObjectCreation(statements, startIndex, out V_0, out V_1)) { return(false); } if (V_0.get_Initializer() != null && V_0.get_Initializer().get_InitializerType() != InitializerType.CollectionInitializer) { return(false); } if (!this.ImplementsInterface(V_0.get_Type(), "System.Collections.IEnumerable")) { return(false); } V_2 = new ExpressionCollection(); V_3 = startIndex + 1; while (V_3 < statements.get_Count() && this.TryGetNextExpression(statements.get_Item(V_3), out V_4) && V_4.get_CodeNodeType() == 19) { V_5 = V_4 as MethodInvocationExpression; V_6 = V_5.get_MethodExpression().get_MethodDefinition(); if (!this.CompareTargets(V_1, V_5.get_MethodExpression().get_Target()) || String.op_Inequality(V_6.get_Name(), "Add") || V_5.get_Arguments().get_Count() == 0) { break; } if (V_5.get_Arguments().get_Count() != 1) { stackVariable88 = V_5.get_Arguments(); stackVariable89 = CollectionInitializationPattern.u003cu003ec.u003cu003e9__1_0; if (stackVariable89 == null) { dummyVar0 = stackVariable89; stackVariable89 = new Func <Expression, Expression>(CollectionInitializationPattern.u003cu003ec.u003cu003e9.u003cTryMatchInternalu003eb__1_0); CollectionInitializationPattern.u003cu003ec.u003cu003e9__1_0 = stackVariable89; } V_7 = new BlockExpression(new ExpressionCollection(stackVariable88.Select <Expression, Expression>(stackVariable89)), null); V_2.Add(V_7); } else { V_2.Add(V_5.get_Arguments().get_Item(0).Clone()); } V_3 = V_3 + 1; } if (V_2.get_Count() == 0) { return(false); } if (V_0.get_Initializer() != null) { V_9 = V_2.GetEnumerator(); try { while (V_9.MoveNext()) { V_10 = V_9.get_Current(); V_0.get_Initializer().get_Expressions().Add(V_10); } } finally { if (V_9 != null) { V_9.Dispose(); } } } else { V_8 = new InitializerExpression(V_2, 0); V_8.set_IsMultiLine(true); V_0.set_Initializer(V_8); } result = statements.get_Item(startIndex); replacedStatementsCount = V_2.get_Count() + 1; return(true); }
private static BlockExpression Update(BlockExpression node) { // Tests the call of Update to Expression.Block factories. var res = node.Update(node.Variables, node.Expressions.ToArray()); Assert.NotSame(node, res); return res; }
public void Init1() { try { var finalExpression = CreateCore(); _func = finalExpression.Compile(); Expression <Func <CreateClaptrapInput, ValidateResult> > CreateCore() { ParameterExpression input = Expression.Parameter(typeof(CreateClaptrapInput), "input"); LabelTarget returnLabel = Expression.Label(typeof(ValidateResult)); ParameterExpression resultExp = Expression.Variable(typeof(ValidateResult)); List <Expression> list = new List <Expression> { CreateDefaultResult() }; foreach (PropertyInfo item in typeof(CreateClaptrapInput).GetProperties().Where(a => a.PropertyType == typeof(string))) { if (item.GetCustomAttribute <RequiredAttribute>() != null) { list.Add(CreateValidate(item, CreateValidateStringRequiredExp())); } var minLength = item.GetCustomAttribute <MinLengthAttribute>(); if (minLength != null) { list.Add(CreateValidate(item, CreateValidateStringMinLengthExp(minLength.Length))); } } list.Add(Expression.Label(returnLabel, resultExp)); var body = Expression.Block(new[] { resultExp }, list.ToArray()); Expression <Func <CreateClaptrapInput, ValidateResult> > expression = Expression.Lambda <Func <CreateClaptrapInput, ValidateResult> >(body, input); return(expression); Expression CreateValidate(PropertyInfo property, Expression <Func <string, string, ValidateResult> > expression) { ConstantExpression nameExp = Expression.Constant(property.Name, typeof(string)); MemberExpression valueExp = Expression.Property(input, property); PropertyInfo isOk = typeof(ValidateResult).GetProperty(nameof(ValidateResult.IsOk)); InvocationExpression result = Expression.Invoke(expression, nameExp, valueExp); BinaryExpression assignExp = Expression.Assign(resultExp, result); UnaryExpression flageExp = Expression.IsFalse(Expression.Property(result, isOk)); ConditionalExpression ifThanExp = Expression.IfThen(flageExp, Expression.Return(returnLabel, resultExp)); BlockExpression re = Expression.Block(new[] { resultExp }, assignExp, ifThanExp); return(re); } Expression CreateDefaultResult() { MethodInfo okMethodInfo = typeof(ValidateResult).GetMethod(nameof(ValidateResult.Ok)); MethodCallExpression callExpression = Expression.Call(okMethodInfo); var re = Expression.Assign(resultExp, callExpression); return(re); } } } catch (Exception ex) { throw ex; } }
private void EmitBranchBlock(bool branch, BlockExpression node, Label label) { EnterScope(node); int count = node.ExpressionCount; for (int i = 0; i < count - 1; i++) { EmitExpressionAsVoid(node.GetExpression(i)); } EmitExpressionAndBranch(branch, node.GetExpression(count - 1), label); ExitScope(node); }
public virtual bool IsEvaluatableBlock(BlockExpression node) { ArgumentUtility.CheckNotNull("node", node); return(true); }
public override Expression VisitBlockExpression(BlockExpression blockExpression){ if (blockExpression == null) return null; Block b = blockExpression.Block = this.VisitBlock(blockExpression.Block); blockExpression.Type = SystemTypes.Void; StatementList statements = b == null ? null : b.Statements; if (statements != null && statements.Count > 0){ ExpressionStatement es = statements[statements.Count-1] as ExpressionStatement; if (es != null && es.Expression != null && es.Expression.Type != null) { blockExpression.Type = es.Expression.Type; if (es.Expression is Literal && statements.Count == 1){ return es.Expression; } } } return blockExpression; }
protected override Expression VisitBlock(BlockExpression node) { return(GiveUp(node)); }
public override Expression VisitBlockExpression(BlockExpression blockExpression) { if (blockExpression == null) return null; blockExpression.Block = this.VisitBlock(blockExpression.Block); return blockExpression; //TODO: give an error. This method should always be overridden }
protected override Expression VisitBlock(BlockExpression node) { return(Visiting((expr) => base.VisitBlock(expr as BlockExpression), node)); }
public virtual Differences VisitBlockExpression(BlockExpression blockExpression1, BlockExpression blockExpression2){ Differences differences = new Differences(blockExpression1, blockExpression2); if (blockExpression1 == null || blockExpression2 == null){ if (blockExpression1 != blockExpression2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } BlockExpression changes = (BlockExpression)blockExpression2.Clone(); BlockExpression deletions = (BlockExpression)blockExpression2.Clone(); BlockExpression insertions = (BlockExpression)blockExpression2.Clone(); Differences diff = this.VisitBlock(blockExpression1.Block, blockExpression2.Block); if (diff == null){Debug.Assert(false); return differences;} changes.Block = diff.Changes as Block; deletions.Block = diff.Deletions as Block; insertions.Block = diff.Insertions as Block; Debug.Assert(diff.Changes == changes.Block && diff.Deletions == deletions.Block && diff.Insertions == insertions.Block); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
public object Visit(BlockExpression block) { return(null); }
public virtual Expression VisitBlockExpression(BlockExpression blockExpression, BlockExpression changes, BlockExpression deletions, BlockExpression insertions){ this.UpdateSourceContext(blockExpression, changes); if (blockExpression == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ blockExpression.Block = this.VisitBlock(blockExpression.Block, changes.Block, deletions.Block, insertions.Block); } }else if (deletions != null) return null; return blockExpression; }
public DoWhileExpression(Token token, BlockExpression block, Expression condition) : base(token) { Block = block; Condition = condition; }