Proposal/example for Quantum union generation

AbilityTargetData.partials.cs

// ReSharper disable all
using System;

namespace Quantum
{
    public partial struct AbilityTargetData
    {
        public static AbilityTargetData newCharacter(EntityRefCharacter _character)
        {
            var data = default(AbilityTargetData);
            data._field_used_ = CHARACTER;
            data._character = _character;
            return data;
        }

        public static AbilityTargetData newMob(EntityRefMob _mob)
        {
            var data = default(AbilityTargetData);
            data._field_used_ = MOB;
            data._mob = _mob;
            return data;
        }

        public enum Discriminator : int
        {
            Character = AbilityTargetData.CHARACTER,
            Mob = AbilityTargetData.MOB,
        }

        public Discriminator discriminator => (Discriminator)_field_used_;
    }
}

data.cs

/*
union AbilityTargetData {
  EntityRefCharacter character;
  EntityRefMob mob;
}
*/
[QuantumUnion(
  fieldTypes = new []{typeof(EntityRefCharacter), typeof(EntityRefMob)},
  fields = new []{nameof(_character), nameof(_mob)}
)]
public partial struct AbilityTargetData {}

/*
union TurretTypeData {
  TurretIndex staticData;
  TurretTypeDynamicData dynamicData;
}
*/
[QuantumUnion(
  fieldTypes = new[] { typeof(TurretIndex), typeof(TurretTypeDynamicData) },
  fields = new[] { nameof(_staticData), nameof(_dynamicData) },
  discriminators = new []{ "Static", "Dynamic" }
)]
public partial struct TurretTypeData {}

QuantumUnion.cs

  [AttributeMacro(@"
{{
# Build the discriminators array
mapped_discriminators = []
if discriminators
  for discriminator in discriminators
    qtn_discriminator = fields[for.index] | string.slice 1 | string.upcase
    obj = {name: discriminator, qtn: qtn_discriminator}
    mapped_discriminators = mapped_discriminators | array.add obj 
  end
else 
  for field in fields
    discriminator = field | string.slice 1 | pascal_case
    qtn_discriminator = discriminator | string.upcase
    obj = {name: discriminator, qtn: qtn_discriminator}
    mapped_discriminators = mapped_discriminators | array.add obj 
  end 
end
}}

{{ for fieldType in fieldTypes }}
  {{ 
    field = fields[for.index]
    discriminator = mapped_discriminators[for.index]
  }}
  public static {{type.short_name}} new{{discriminator.name}}({{fieldType.short_name}} {{field}}) {
    var data = default({{type.short_name}});
    data._field_used_ = {{mapped_discriminators[for.index].qtn}};
    data.{{field}} = {{field}};
    return data;
  }
{{ end }}

public enum Discriminator : int {
{{ for discriminator in mapped_discriminators }}
  {{discriminator.name}} = {{type.short_name}}.{{discriminator.qtn}},
{{ end }}
}

public Discriminator discriminator => (Discriminator) _field_used_;
")]
  public class QuantumUnionAttribute : Attribute {
    /// <summary>Types of union fields. Must have same length as <see cref="fields"/>.</summary>
    [UsedImplicitly] public Type[] fieldTypes;
    /// <summary>Names of union fields. Must have same length as <see cref="fieldTypes"/>.</summary>
    [UsedImplicitly] public string[] fields;
    /// <summary>
    /// Names of discriminators. Can be empty, then they will be computed out of <see cref="fields"/>.
    ///
    /// If specified, must have same length as <see cref="fieldTypes"/>.
    /// </summary>
    [UsedImplicitly] public string[] discriminators;
  }

TurretTypeData.partials.cs

namespace Quantum
{
    public partial struct TurretTypeData
    {
        public static TurretTypeData newStatic(TurretIndex _staticData)
        {
            var data = default(TurretTypeData);
            data._field_used_ = STATICDATA;
            data._staticData = _staticData;
            return data;
        }

        public static TurretTypeData newDynamic(TurretTypeDynamicData _dynamicData)
        {
            var data = default(TurretTypeData);
            data._field_used_ = DYNAMICDATA;
            data._dynamicData = _dynamicData;
            return data;
        }

        public enum Discriminator : int
        {
            Static = TurretTypeData.STATICDATA,
            Dynamic = TurretTypeData.DYNAMICDATA,
        }

        public Discriminator discriminator => (Discriminator)_field_used_;
    }
}