NativeAOT / trimming / IL2CPP support for ChibiRuby.Serializer (fixes #199)

[hadashiA]

Summary

Makes ChibiRuby.Serializer fully AOT-safe, following the approach MessagePack-CSharp v3/v4 took (statically-rooted, source-generated registration; no runtime reflection or MakeGenericType). Fixes #199 (supersedes #200) and makes the NativeAOT sanity suite pass, where previously every check failed.

Phase 1 — statically rooted registration (module initializer)

The source generator now emits one [ModuleInitializer] per assembly that calls every generated type's __RegisterMRubyValueFormatter() on assembly load. Registration no longer depends on reflection or on [MRubyObject] attribute instances at runtime, so it survives .NET trimming, NativeAOT, Unity managed stripping, and Unity 6000.5's Preserve-attribute-instance removal (#199). A ModuleInitializerAttribute polyfill is emitted only when the target framework lacks it (netstandard2.1 / Unity, verified against a C# 9 netstandard2.1 consumer).

Phase 2 — compile-time closed-generic instantiation

__RegisterMRubyValueFormatter now also registers fully-constructed formatter instantiations for every type reachable from the [MRubyObject] member graph — arrays (1–4 dims), enums, Nullable<T>, and all collections known to BuiltinResolver — recursively (e.g. Dictionary<string, List<MyStruct[]>>). A re-entrancy guard makes self-/mutually-referencing types cycle-safe. BuiltinResolver's dynamic path now catches NotSupportedException/MissingMethodException and returns null so resolution falls through to these registrations (JIT and IL2CPP full-generic-sharing behavior is unchanged). EnumAsStringFormatter uses Enum.GetValues<T>() (constraint tightened to struct, Enum) to clear IL3050.

Phase 3 — call-site-only root declaration

New [assembly: MRubyFormattable(typeof(List<double>))] declares serializable types that appear only at Serialize<T>/Deserialize<T> call sites, which the generator cannot see. Closed generics of [MRubyObject] types are supported; open generics get a new MRBCS010 warning. This is the ChibiRuby analogue of MessagePack v4's [MessagePackSerializable<T>] root declaration.

Phase 4 — annotations & CI verification

• IsAotCompatible on net8.0+ targets; remaining intentional dynamic paths carry UnconditionalSuppressMessage with justifications; publish is IL-warning-free.
• sandbox/NativeAotSanity: a PublishAot console app covering the member graph (enum/nullable/collections), call-site int[], and MRubyFormattable roots. Runs in a new test-nativeaot CI job and treats IL2xxx/IL3xxx warnings as errors.
• README gains a "NativeAOT / trimming / IL2CPP" section.

The reflection lookup in GeneratedResolver is kept (attribute gate removed, per #199) purely as a fallback for assemblies compiled with older generator versions.

Verification

• All 5 test projects pass (268 tests), including new tests for eager member registrations, MRubyFormattable roots, and the reflection fallback; the incremental-generator caching test still passes with the new aggregate output.
• dotnet publish -r osx-arm64 of NativeAotSanity: zero IL warnings, all checks pass at runtime (before this change, every check failed with MRubySerializationException / NotSupportedException / MissingMethodException).
• netstandard2.1 + LangVersion 9 consumer (Unity-equivalent) compiles cleanly with the emitted polyfill.

Notes / limitations

• Generic [MRubyObject] types are not called from the module initializer (an open generic cannot be); closed instantiations can be rooted via [assembly: MRubyFormattable(typeof(X<int>))].
• The emitted ModuleInitializerAttribute polyfill could collide with another generator emitting the same polyfill (e.g. PolySharp) in a netstandard2.1 assembly — modern TFMs never emit it.

🤖 Generated with Claude Code