bug: Sequential enum GetFormattedLength lacks bounds check for invalid enum values

[DrBarnabus]

Description

The generated CustomEnumHelper for sequential enums uses array indexing in GetFormattedLength without validating the enum value:

public static int GetFormattedLength(CustomEnum value) => Lengths[(int)value];

An out-of-range enum value will throw a raw IndexOutOfRangeException rather than a descriptive ArgumentOutOfRangeException.

In contrast, the switch-based helper generated for non-sequential enums throws a descriptive ArgumentOutOfRangeException for invalid values. The TryFormat method in the same sequential helper does include a bounds check ((uint)value >= Names.Length), so GetFormattedLength is inconsistent with its sibling.

Reproduction

Visible in the snapshot baseline:
SourceGeneratorSnapshotTests.BasicCompositePrimaryKey_SourceOutput#UnitTests.BasicPrimaryKey.g.verified.cs (lines ~266-274)

Expected behaviour

GetFormattedLength should validate the enum value and throw ArgumentOutOfRangeException for invalid values, consistent with the non-sequential enum helper and the TryFormat guard in the same class.

Discovered via

Snapshot testing added in #48 — this is a pre-existing generator issue, not a regression.

[DrBarnabus]

Investigation

Root Cause

In EnumGenerationHelper.cs:37, the sequential enum path for GetFormattedLength emits:

return Lengths[(uint)value];

This performs a raw array index with no bounds check. If an invalid/out-of-range enum value is passed (e.g. (CustomEnum)99), the code throws IndexOutOfRangeException instead of a descriptive ArgumentOutOfRangeException.

Inconsistencies

1. Non-sequential vs sequential GetFormattedLength: The non-sequential path uses a switch expression with a _ => throw new ArgumentOutOfRangeException(...) default arm (EnumGenerationHelper.cs:46). The sequential path has no equivalent guard.

2. TryFormat vs GetFormattedLength within the same sequential helper: TryFormat (EnumGenerationHelper.cs:58) already has if ((uint)value >= Names.Length) return false; before indexing the array, but GetFormattedLength does not.

Impact

• Severity: Low — only affects invalid enum values, which shouldn't occur in normal usage
• User-facing symptom: Calling ToString(), ToPartitionKeyString(), or ToSortKeyString() on a key type with a sequential enum property set to an invalid value produces a confusing IndexOutOfRangeException instead of a clear ArgumentOutOfRangeException
• The string.Create(...) call uses GetFormattedLength to calculate the buffer length, so the raw exception surfaces from there

Replication

Visible in snapshot baselines — compare sequential vs non-sequential:

• Sequential (bug): BasicCompositePrimaryKey_SourceOutput#UnitTests.BasicPrimaryKey.g.verified.cs lines 271-274
• Non-sequential (correct): BasicNonSequentialEnumPrimaryKey_SourceOutput#UnitTests.BasicNonSequentialEnum.g.verified.cs lines 268-277

Runtime reproduction:

var key = new BasicPrimaryKey
{
    FirstPart = Guid.NewGuid(),
    SecondPart = "test",
    ThirdPart = (CustomEnum)99  // invalid value
};
key.ToString(); // Throws IndexOutOfRangeException instead of ArgumentOutOfRangeException

Categorization

• Type: Bug (incorrect exception type / missing bounds check)
• Severity: Low
• Component: CompositeKey.SourceGeneration — EnumGenerationHelper.cs
• Affected code path: Sequential enum GetFormattedLength generation only

Proposed Fix

Single-line change in EnumGenerationHelper.cs — WriteGetFormattedLengthMethod, line 37. Replace:

writer.WriteLine("return Lengths[(uint)value];");

With a bounds check that throws ArgumentOutOfRangeException, consistent with TryFormat's guard and the non-sequential path:

writer.WriteLines("""
                  if ((uint)value >= Lengths.Length)
                      throw new ArgumentOutOfRangeException(nameof(value), value, "The value provided is out of range.");

                  return Lengths[(uint)value];
                  """);

This will also require updating the snapshot baseline for BasicCompositePrimaryKey_SourceOutput#UnitTests.BasicPrimaryKey.g.verified.cs to reflect the new generated code.