Fields.tt

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".autogen.cs" #>
using System;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using JetBrains.Annotations;

namespace ILGeneratorExtensions
{
	[PublicAPI]
    public static partial class Fields
    {
<# foreach (var type in new [] { typeof(bool), typeof(char), typeof(sbyte), typeof(byte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double)}) { #>
		/// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the given field for that object
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="field">The field to store the value in</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
		[PublicAPI]
		public static ILGenerator OverwriteFieldWith(this ILGenerator generator, FieldInfo field, <#= type.Name #> value)
		{
			if (field.FieldType != typeof(<#= type.Name #>))
			{
				throw new InvalidOperationException("Type mismatch - field is of type " + field.FieldType);
			}

			return generator.LoadConstant(value)
							.StoreInField(field);
		}

		/// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field (with the given name on the given type) for that object
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="type">The type the field is on</param>
        /// <param name="fieldName">The name of the field</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWith(this ILGenerator generator, Type type, string fieldName, <#= type.Name #> value)
            => generator.OverwriteFieldWith(GetFieldInfo(type, fieldName), value);

        /// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field (with the given name on the given type) for that object
        /// </summary>
        /// <typeparam name="T">The type the field is on</typeparam>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldName">The name of the field</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWith<T>(this ILGenerator generator, string fieldName, <#= type.Name #> value)
            => generator.OverwriteFieldWith(typeof(T), fieldName, value);

        /// <summary>
        /// Stores the given value in the static field represented by the given expression
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldExpression">An expression representing the field to load</param>
		/// <param name="value">The value to overwrite the field with</param>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWith(this ILGenerator generator, Expression<Func<<#= type.Name #>>> fieldExpression, <#= type.Name #> value)
            => generator.OverwriteFieldWith(GetFieldInfo(fieldExpression), value);

        /// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field represented by the given expression for that object
        /// </summary>
        /// <typeparam name="T">The type the field is on</typeparam>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldExpression">An expression representing the field to load</param>
		/// <param name="value">The value to overwrite the field with</param>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWith<T>(this ILGenerator generator, Expression<Func<T, <#= type.Name #>>> fieldExpression, <#= type.Name #> value)
            => generator.OverwriteFieldWith(GetFieldInfo(fieldExpression), value);

		/// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the given field for that object, with volatile semantics
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="field">The field to store the value in</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
		[PublicAPI]
		public static ILGenerator OverwriteFieldWithVolatile(this ILGenerator generator, FieldInfo field, <#= type.Name #> value)
		{
			if (field.FieldType != typeof(<#= type.Name #>))
			{
				throw new InvalidOperationException("Type mismatch - field is of type " + field.FieldType);
			}

			return generator.LoadConstant(value)
							.FluentEmit(OpCodes.Volatile)
							.StoreInField(field);
		}

		/// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field (with the given name on the given type) for that object, with volatile semantics
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="type">The type the field is on</param>
        /// <param name="fieldName">The name of the field</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWithVolatile(this ILGenerator generator, Type type, string fieldName, <#= type.Name #> value)
            => generator.OverwriteFieldWithVolatile(GetFieldInfo(type, fieldName), value);

        /// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field (with the given name on the given type) for that object, with volatile semantics
        /// </summary>
        /// <typeparam name="T">The type the field is on</typeparam>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldName">The name of the field</param>
		/// <param name="value">The value to overwrite the field with</param>
		/// <exception cref="InvalidOperationException">Thrown if the field is not of type <see cref="<#= type.Name #>" /></exception>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWithVolatile<T>(this ILGenerator generator, string fieldName, <#= type.Name #> value)
            => generator.OverwriteFieldWithVolatile(typeof(T), fieldName, value);

        /// <summary>
        /// Stores the given value in the static field represented by the given expression, with volatile semantics
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldExpression">An expression representing the field to load</param>
		/// <param name="value">The value to overwrite the field with</param>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWithVolatile(this ILGenerator generator, Expression<Func<<#= type.Name #>>> fieldExpression, <#= type.Name #> value)
            => generator.OverwriteFieldWithVolatile(GetFieldInfo(fieldExpression), value);

        /// <summary>
        /// Pops a reference from the evaluation stack and stores the given value in the field represented by the given expression for that object, with volatile semantics
        /// </summary>
        /// <typeparam name="T">The type the field is on</typeparam>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="fieldExpression">An expression representing the field to load</param>
		/// <param name="value">The value to overwrite the field with</param>
        [PublicAPI]
        public static ILGenerator OverwriteFieldWithVolatile<T>(this ILGenerator generator, Expression<Func<T, <#= type.Name #>>> fieldExpression, <#= type.Name #> value)
            => generator.OverwriteFieldWithVolatile(GetFieldInfo(fieldExpression), value);
<# } #>
	}
}