private void EmitPopIfNeeded(EmitContext emitContext)
 {
     if (GetReturnType() == typeof(void) && body.Type != typeof(void))
     {
         emitContext.ig.Emit(OpCodes.Pop);
     }
 }

		void EmitPopIfNeeded (EmitContext ec)
		{
			if (add_method.ReturnType == typeof (void))
				return;

			ec.ig.Emit (OpCodes.Pop);
		}

		internal override void Emit (EmitContext ec)
		{
			ec.EmitIsInst (expression, type_operand);

			ec.ig.Emit (OpCodes.Ldnull);
			ec.ig.Emit (OpCodes.Cgt_Un);
		}

		LocalBuilder EmitLoadField (EmitContext ec, FieldInfo field)
		{
			var store = ec.ig.DeclareLocal (field.FieldType);
			ec.ig.Emit (OpCodes.Ldfld, field);
			ec.ig.Emit (OpCodes.Stloc, store);
			return store;
		}

		internal override void Emit (EmitContext ec)
		{
			var ig = ec.ig;
			var type = this.Type;

			LocalBuilder local = null;
			if (type.IsValueType) {
				local = ig.DeclareLocal (type);
				ig.Emit (OpCodes.Ldloca, local);

				if (constructor == null) {
					ig.Emit (OpCodes.Initobj, type);
					ig.Emit (OpCodes.Ldloc, local);
					return;
				}
			}

			ec.EmitCollection (arguments);

			if (type.IsValueType) {
				ig.Emit (OpCodes.Call, constructor);
				ig.Emit (OpCodes.Ldloc, local);
			} else
				ig.Emit (OpCodes.Newobj, constructor ?? GetDefaultConstructor (type));
		}

		internal override void Emit (EmitContext ec, LocalBuilder local)
		{
			var member = EmitLoadMember (ec, local);

			foreach (var initializer in initializers)
				initializer.Emit (ec, member);
		}

		internal override void Emit (EmitContext ec, LocalBuilder local)
		{
			var member = EmitLoadMember (ec, local);

			foreach (var binding in bindings)
				binding.Emit (ec, member);
		}

		void EmitPropertyAccess (EmitContext ec, PropertyInfo property)
		{
			var getter = property.GetGetMethod (true);
			if (!getter.IsStatic)
				ec.EmitLoadSubject (expression);

			ec.EmitCall (getter);
		}

		void EmitFieldAccess (EmitContext ec, FieldInfo field)
		{
			if (!field.IsStatic) {
				ec.EmitLoadSubject (expression);
				ec.ig.Emit (OpCodes.Ldfld, field);
			} else
				ec.ig.Emit (OpCodes.Ldsfld, field);
		}

		internal LocalBuilder EmitLoadMember (EmitContext ec, LocalBuilder local)
		{
			ec.EmitLoadSubject (local);

			return member.OnFieldOrProperty<LocalBuilder> (
				field => EmitLoadField (ec, field),
				prop => EmitLoadProperty (ec, prop));
		}

 internal override void Emit(EmitContext emitContext)
 {
     _member.OnFieldOrProperty
     (
         field => EmitFieldAccess(emitContext, field),
         prop => EmitPropertyAccess(emitContext, prop)
     );
 }

 private void EmitPopIfNeeded(EmitContext emitContext)
 {
     if (_addMethod.ReturnType == typeof(void))
     {
         return;
     }
     emitContext.ig.Emit(OpCodes.Pop);
 }

 internal LocalBuilder EmitLoadMember(EmitContext emitContext, LocalBuilder local)
 {
     emitContext.EmitLoadSubject(local);
     return _member.OnFieldOrProperty
     (
         field => EmitLoadField(emitContext, field),
         prop => EmitLoadProperty(emitContext, prop)
     );
 }

 private void EmitPropertyAccess(EmitContext emitContext, PropertyInfo property)
 {
     var getter = property.GetGetMethod(true);
     if (!getter.IsStatic)
     {
         emitContext.EmitLoadSubject(_expression);
     }
     emitContext.EmitCall(getter);
 }

		void EmitTypeAs (EmitContext ec)
		{
			var type = this.Type;

			ec.EmitIsInst (operand, type);

			if (type.IsNullable ())
				ec.ig.Emit (OpCodes.Unbox_Any, type);
		}

		internal override void Emit (EmitContext ec)
		{
			if (Type.IsNullable ()) {
				EmitNullableConstant (ec, Type, value);
				return;
			}

			EmitConstant (ec, Type, value);
		}

		void EmitNullableConstant (EmitContext ec, Type type, object value)
		{
			if (value == null) {
				var local = ec.ig.DeclareLocal (type);
				ec.EmitNullableInitialize (local);
			} else {
				EmitConstant (ec, type.GetFirstGenericArgument (), value);
				ec.EmitNullableNew (type);
			}
		}

		void EmitPropertyAssignment (EmitContext ec, PropertyInfo property, LocalBuilder local)
		{
			var setter = property.GetSetMethod (true);
			if (setter == null)
				throw new InvalidOperationException ();

			ec.EmitLoadSubject (local);
			expression.Emit (ec);
			ec.EmitCall (setter);
		}

 private void EmitNewArrayBounds(EmitContext emitContext, Type type)
 {
     int rank = _expressions.Count;
     emitContext.EmitCollection(_expressions);
     if (rank == 1)
     {
         emitContext.ig.Emit(OpCodes.Newarr, type);
         return;
     }
     emitContext.ig.Emit(OpCodes.Newobj, GetArrayConstructor(type, rank));
 }

		LocalBuilder EmitLoadProperty (EmitContext ec, PropertyInfo property)
		{
			var getter = property.GetGetMethod (true);
			if (getter == null)
				throw new NotSupportedException ();

			var store = ec.ig.DeclareLocal (property.PropertyType);
			ec.EmitCall (getter);
			ec.ig.Emit (OpCodes.Stloc, store);
			return store;
		}