Summary

Adds array element type discrimination for oneOf/anyOf schemas, enabling automatic variant selection when variants differ by their array element types (e.g., string[] vs integer[]).

This feature is conservative - it only enables array element discrimination when variants also have at least one unique field by name, ensuring reliable fallback when the array field is missing or empty.

Changes

• Add ArrayElementType and ArrayElementTypeID to UniqueFieldVariant IR metadata
• Add getArrayElementTypeInfo() to extract element types from array type IDs
• Update validation to allow discrimination when array element types differ AND other unique fields exist
• Generate decoder code that peeks into arrays using d.Capture() and d.ArrIter()

Example Schema

oneOf:
  - properties:
      items: { type: array, items: { type: string } }   # string[]
      stringInfo: { type: string }                       # unique field
  - properties:
      items: { type: array, items: { type: integer } }  # integer[]
      intInfo: { type: integer }                         # unique field

Before: "type-based discrimination with same jxType" error
After: Generates working decoder that peeks at first element

Generated Code

case "items":
    if typ := d.Next(); typ != jx.Array {
        return d.Skip()
    }
    if err := d.Capture(func(d *jx.Decoder) error {
        iter, err := d.ArrIter()
        if err != nil { return err }
        if !iter.Next() {
            // Empty array - use first variant as default
            s.Type = StringArrayVariantBasicArrayResource
            return nil
        }
        switch d.Next() {
        case jx.String:
            s.Type = StringArrayVariantBasicArrayResource
        case jx.Number:
            s.Type = IntegerArrayVariantBasicArrayResource
        }
        return nil
    }); err != nil { return err }

Testing

• Test spec: _testdata/positive/array_element_discrimination.json
• Covers: basic primitives with fallback fields, object vs primitive arrays, mixed discrimination
• All existing tests pass

Limitations (Future Work)

• Nested arrays (array[array[string]] vs array[array[integer]]) - requires recursive peeking
• Complex object arrays where both have same object type - requires field checking within objects
• Array element discrimination is NOT allowed as sole discriminator (requires other unique fields)

🤖 Generated with Claude Code