protected virtual Expression CompileDereference(Compiler compiler, Frame frame, Expression left, Parse.BinaryExpression expression, System.Type typeHint) { left = compiler.MaterializeReference(left); var local = compiler.AddFrame(frame, expression); var memberType = left.Type.GenericTypeArguments[0]; var parameters = new List<ParameterExpression>(); var valueParam = compiler.CreateValueParam(expression, local, left, memberType); parameters.Add(valueParam); var indexParam = compiler.CreateIndexParam(expression, local); parameters.Add(indexParam); var right = compiler.MaterializeReference ( compiler.CompileExpression(local, expression.Right, typeHint) ); var selection = Expression.Lambda(right, parameters); var select = typeof(Enumerable).GetMethodExt ( "Select", new System.Type[] { typeof(IEnumerable<ReflectionUtility.T>), typeof(Func<ReflectionUtility.T, int, ReflectionUtility.T>) } ); select = select.MakeGenericMethod(memberType, selection.ReturnType); return Expression.Call(select, left, selection); }
private Expression CompileDereference(Compiler compiler, Frame frame, Expression left, Parse.BinaryExpression expression, System.Type typeHint) { left = compiler.MaterializeReference(left); var local = compiler.AddFrame(frame, expression); foreach (var field in left.Type.GetFields(BindingFlags.Public | BindingFlags.Instance)) { local.Add(expression, Name.FromNative(field.Name), field); var fieldExpression = Expression.Field(left, field); compiler.ExpressionsBySymbol.Add(field, fieldExpression); } return compiler.CompileExpression(local, expression.Right, typeHint); }
// Restriction public override ExpressionContext CompileExtractExpression(Compiler compiler, Frame frame, ExpressionContext left, Parse.ExtractExpression expression, BaseType typeHint) { var local = compiler.AddFrame(frame, expression); var alreadyOptional = left.Type is OptionalType; var memberNative = left.Type.GetNative(compiler.Emitter); var resultType = alreadyOptional ? left.Type : new OptionalType(left.Type); var resultNative = resultType.GetNative(compiler.Emitter); // Register value symbol LocalBuilder valueLocal = null; var localSymbol = new Object(); local.Add(expression.Condition, Name.FromComponents(Parse.ReservedWords.Value), localSymbol); compiler.ContextsBySymbol.Add ( localSymbol, new ExpressionContext ( null, left.Type, left.Characteristics, m => { m.IL.Emit(OpCodes.Ldloc, valueLocal); } ) ); var condition = compiler.CompileExpression(local, expression.Condition, SystemTypes.Boolean); if (!(condition.Type is BooleanType)) throw new CompilerException(expression.Condition, CompilerException.Codes.IncorrectType, condition.Type, "Boolean"); return new ExpressionContext ( expression, resultType, Compiler.MergeCharacteristics(left.Characteristics, condition.Characteristics), m => { var nullLabel = m.IL.DefineLabel(); var endLabel = m.IL.DefineLabel(); // Register value argument valueLocal = m.DeclareLocal(expression, memberNative, Parse.ReservedWords.Value); left.EmitGet(m); m.IL.Emit(OpCodes.Stloc, valueLocal); condition.EmitGet(m); m.IL.Emit(OpCodes.Brfalse, nullLabel); // Passed condition if (!alreadyOptional && memberNative.IsValueType) { var optionalLocal = m.DeclareLocal(expression, resultNative, Parse.ReservedWords.Value); m.IL.Emit(OpCodes.Ldloca, optionalLocal); m.IL.Emit(OpCodes.Ldloc, valueLocal); m.IL.Emit(OpCodes.Call, resultNative.GetConstructor(new System.Type[] { left.Type.GetNative(compiler.Emitter) })); m.IL.Emit(OpCodes.Ldloc, optionalLocal); } else m.IL.Emit(OpCodes.Ldloc, valueLocal); m.IL.Emit(OpCodes.Br, endLabel); // Failed condition m.IL.MarkLabel(nullLabel); if (!alreadyOptional && memberNative.IsValueType) { var optionalLocal = m.DeclareLocal(expression, resultNative, Parse.ReservedWords.Value); m.IL.Emit(OpCodes.Ldloca, optionalLocal); m.IL.Emit(OpCodes.Initobj, resultNative); m.IL.Emit(OpCodes.Ldloc, optionalLocal); } else if (alreadyOptional && memberNative.IsValueType) { m.IL.Emit(OpCodes.Ldloca, valueLocal); m.IL.Emit(OpCodes.Initobj, resultNative); m.IL.Emit(OpCodes.Ldloc, valueLocal); } else m.IL.Emit(OpCodes.Ldnull); m.IL.MarkLabel(endLabel); } ); }
private ExpressionContext CompileDereference(Compiler compiler, Frame frame, ExpressionContext left, Parse.BinaryExpression expression, Type.BaseType typeHint) { var local = compiler.AddFrame(frame, expression); var native = left.ActualNative(compiler.Emitter); LocalBuilder valueVariable = null; // Create symbol for each tuple member foreach (var a in ((TupleType)left.Type).Attributes) { var field = native.GetField(a.Key.ToString(), BindingFlags.Public | BindingFlags.Instance); local.Add(expression, a.Key, field); compiler.ContextsBySymbol.Add ( field, new ExpressionContext ( null, a.Value, Characteristic.Default, m => { m.IL.Emit(OpCodes.Ldloc, valueVariable); m.IL.Emit(OpCodes.Ldfld, field); } ) ); } var right = compiler.CompileExpression(local, expression.Right, typeHint); return new ExpressionContext ( expression, right.Type, Compiler.MergeCharacteristics(left.Characteristics, right.Characteristics), m => { m.IL.BeginScope(); left.EmitGet(m); valueVariable = m.DeclareLocal(expression.Right, native, "value"); m.IL.Emit(OpCodes.Stloc, valueVariable); right.EmitGet(m); m.IL.EndScope(); } ); }
// Restriction public override ExpressionContext CompileExtractExpression(Compiler compiler, Frame frame, ExpressionContext left, Parse.ExtractExpression expression, BaseType typeHint) { var memberType = ((NaryType)left.Type).Of; var memberNative = left.NativeType ?? memberType.GetNative(compiler.Emitter); var local = compiler.AddFrame(frame, expression); // Prepare index and value symbols var indexSymbol = PrepareValueIndexContext(compiler, left, expression.Condition, memberType, memberNative, local); // Compile condition var condition = compiler.CompileExpression(local, expression.Condition, SystemTypes.Boolean); if (!(condition.Type is BooleanType)) throw new CompilerException(expression.Condition, CompilerException.Codes.IncorrectType, condition.Type, "Boolean"); var indexReferenced = compiler.References.ContainsKey(indexSymbol); return new ExpressionContext ( expression, left.Type, Compiler.MergeCharacteristics(left.Characteristics, condition.Characteristics), m => { // Create a new private method for the condition var typeBuilder = (TypeBuilder)m.Builder.DeclaringType; var innerMethod = new MethodContext ( typeBuilder.DefineMethod ( "Where" + expression.GetHashCode(), MethodAttributes.Private | MethodAttributes.Static, typeof(bool), // return type indexReferenced ? new System.Type[] { memberNative, typeof(int) } : new System.Type[] { memberNative } // param types ) ); condition.EmitGet(innerMethod); innerMethod.IL.Emit(OpCodes.Ret); left.EmitGet(m); // TODO: Force ordering to left if Set and index is referenced // Instantiate a delegate pointing to the new method m.IL.Emit(OpCodes.Ldnull); // instance m.IL.Emit(OpCodes.Ldftn, innerMethod.Builder); // method var funcType = indexReferenced ? System.Linq.Expressions.Expression.GetFuncType(memberNative, typeof(int), typeof(bool)) : System.Linq.Expressions.Expression.GetFuncType(memberNative, typeof(bool)); m.IL.Emit ( OpCodes.Newobj, funcType.GetConstructor(new[] { typeof(object), typeof(IntPtr) }) ); funcType = indexReferenced ? typeof(Func<ReflectionUtility.T, int, bool>) : typeof(Func<ReflectionUtility.T, bool>); var where = typeof(System.Linq.Enumerable).GetMethodExt("Where", new System.Type[] { typeof(IEnumerable<ReflectionUtility.T>), funcType }); where = where.MakeGenericMethod(memberNative); m.IL.EmitCall(OpCodes.Call, where, null); } ); }
protected virtual ExpressionContext CompileDereference(Compiler compiler, Frame frame, ExpressionContext left, Parse.BinaryExpression expression, Type.BaseType typeHint) { var memberType = ((NaryType)left.Type).Of; var memberNative = left.NativeType ?? memberType.GetNative(compiler.Emitter); var local = compiler.AddFrame(frame, expression); // Prepare index and value symbols var indexSymbol = PrepareValueIndexContext(compiler, left, expression.Right, memberType, memberNative, local); // Compile selection var selection = compiler.CompileExpression(local, expression.Right); var indexReferenced = compiler.References.ContainsKey(indexSymbol); return new ExpressionContext ( expression, new ListType(selection.Type), Compiler.MergeCharacteristics(left.Characteristics, selection.Characteristics), m => { // Create a new private method for the condition var typeBuilder = (TypeBuilder)m.Builder.DeclaringType; var innerMethod = new MethodContext ( typeBuilder.DefineMethod ( "Select" + expression.GetHashCode(), MethodAttributes.Private | MethodAttributes.Static, selection.ActualNative(compiler.Emitter), // temporary return type indexReferenced ? new System.Type[] { memberNative, typeof(int) } : new System.Type[] { memberNative } // param types ) ); selection.EmitGet(innerMethod); innerMethod.IL.Emit(OpCodes.Ret); left.EmitGet(m); // TODO: Force ordering of Left if a set and index is referenced // Instantiate a delegate pointing to the new method m.IL.Emit(OpCodes.Ldnull); // instance m.IL.Emit(OpCodes.Ldftn, innerMethod.Builder); // method var funcType = indexReferenced ? System.Linq.Expressions.Expression.GetFuncType(memberNative, typeof(int), innerMethod.Builder.ReturnType) : System.Linq.Expressions.Expression.GetFuncType(memberNative, innerMethod.Builder.ReturnType); m.IL.Emit ( OpCodes.Newobj, funcType.GetConstructor(new[] { typeof(object), typeof(IntPtr) }) ); funcType = indexReferenced ? typeof(Func<ReflectionUtility.T, int, ReflectionUtility.T>) : typeof(Func<ReflectionUtility.T, ReflectionUtility.T>); var select = typeof(Enumerable).GetMethodExt ( "Select", new System.Type[] { typeof(IEnumerable<ReflectionUtility.T>), funcType } ); select = select.MakeGenericMethod(memberNative, innerMethod.Builder.ReturnType); m.IL.EmitCall(OpCodes.Call, select, null); } ); }