/// <summary>Emits the Value held by this compiled fragment if possible.</summary>
 /// <param name="type">The type of the value (or one of the base types of the value).</param>
 /// <param name="into">The IL stream to output the IL into.</param>
 public void EmitValue(Type type, NitroIL into)
 {
     if (type == typeof(string))
     {
         into.Emit(OpCodes.Ldstr, (string)Value);
     }
     else if (type == typeof(int))
     {
         into.Emit(OpCodes.Ldc_I4, (int)Value);
     }
     else if (type == typeof(uint))
     {
         into.Emit(OpCodes.Ldc_I4, (uint)Value);
     }
     else if (type == typeof(long))
     {
         into.Emit(OpCodes.Ldc_I8, (long)Value);
     }
     else if (type == typeof(ulong))
     {
         into.Emit(OpCodes.Ldc_I8, (ulong)Value);
     }
     else if (type == typeof(float))
     {
         into.Emit(OpCodes.Ldc_R4, (float)Value);
     }
     else if (type == typeof(double))
     {
         into.Emit(OpCodes.Ldc_R8, (double)Value);
     }
     else if (type == typeof(OpCode))
     {
         into.Emit((OpCode)Value);
     }
     else if (type == typeof(bool))
     {
         into.Emit(OpCodes.Ldc_I4, ((bool)Value)?1:0);
     }
     else if (type == typeof(short))
     {
         into.Emit(OpCodes.Ldc_I4, (short)Value);
     }
     else if (type == typeof(ushort))
     {
         into.Emit(OpCodes.Ldc_I4, (ushort)Value);
     }
     else if (type == typeof(byte))
     {
         into.Emit(OpCodes.Ldc_I4, (byte)Value);
     }
     else if (type == typeof(sbyte))
     {
         into.Emit(OpCodes.Ldc_I4, (sbyte)Value);
     }
     else if (Types.IsSubclass(Value, typeof(Variable)))
     {
         // Is parent a type of methodoperation or propertyoperation?
         // If it is, IsMemberAccessor is true.
         ((Variable)Value).OutputIL(into, (ParentFragment != null && ParentFragment.IsMemberAccessor()));
     }
     else
     {
         Error("Didn't know how to output value " + Value + " (type is " + type + ")");
     }
 }
        public override void OutputIL(NitroIL into)
        {
            if (!OutputTarget(into))
            {
                return;
            }

            if (Field != null)
            {
                if (Field.IsLiteral)
                {
                    // Special case - this field isn't actually a field at all!
                    // Load it's literal value:
                    object literalFieldValue = Field.GetValue(null);

                    // Get ready to write out the literal value:
                    CompiledFragment literalValue = new CompiledFragment(literalFieldValue);

                    // It might even be from an enum - let's check:
                    if (Field.FieldType.IsEnum)
                    {
                        // Ok great it's from an enum. What type is it?
                        Type literalValueType = Enum.GetUnderlyingType(Field.FieldType);

                        // Use that type to emit the value:
                        literalValue.EmitValue(literalValueType, into);
                    }
                    else
                    {
                        literalValue.OutputIL(into);
                    }
                }
                else if (ParentFragment != null && ParentFragment.IsMemberAccessor() && Field.FieldType.IsValueType)
                {
                    // Are we followed by another PropertyOperation?
                    // A following operation in this sitation ends up being the parent.
                    // If we are, and we output a valuetype, Ldflda must be used.

                    if (IsStatic)
                    {
                        into.Emit(OpCodes.Ldsflda, Field);
                    }
                    else
                    {
                        into.Emit(OpCodes.Ldflda, Field);
                    }
                }
                else if (IsStatic)
                {
                    into.Emit(OpCodes.Ldsfld, Field);
                }
                else
                {
                    into.Emit(OpCodes.Ldfld, Field);
                }
            }
            else if (Property != null)
            {
                bool useVirtual = !IsStatic && !Property.PropertyType.IsValueType;

                into.Emit(useVirtual?OpCodes.Callvirt:OpCodes.Call, Property.GetGetMethod());
            }
            else if (Methods != null)
            {
                // Extension property (hopefully!). Look for a get method lookalike.

                // Get types:
                Type[] argTypes = new Type[] { OfType() };

                // Get the overload:
                MethodInfo getMethod = Types.GetOverload(Methods, argTypes);

                if (getMethod == null)
                {
                    Error(Name + " is a 'write only' extension property.");
                }

                // Call the set method:
                into.Emit(OpCodes.Call, getMethod);
            }
            else
            {
                DynamicMethodCompiler.Compile(Method, Name, MethodReturnType, Of).OutputIL(into);
            }
        }