Fixes #2231

AI Disclaimer
The first commit (937b960) and this text was handwritten.
The merge commit and last commit were made together with Copilot; to revert most of the changes that I made in the first commit 😅

The rest of the description is also put together with Copilot so it's easier to understand (English is my second language) 😉
All decisions were made and validated by me, so if anything needs to be changed feel free to ask.

Why AOT Didn't Work Before

FluentMigrator previously relied entirely on runtime reflection to find migration types:

1. Assembly scanning — AddFluentMigratorCore() registered AssemblySource and AssemblyTypeSource, which use AppDomain.GetAssemblies() and Assembly.GetExportedTypes() to discover all migration types at runtime. The .NET trimmer cannot statically determine which types will be loaded through these code paths, so it may strip required types from the output.

2. Missing [RequiresUnreferencedCode] annotations — None of the reflection-heavy APIs carried trimming annotations. Trimmed builds would silently produce incorrect binaries with no compiler warnings.

3. Anonymous-type overloads — Row(object anonymousType), Set(object), etc. use GetProperties() at runtime to read the object''s properties. The trimmer removes property metadata unless explicitly preserved.

4. Assembly loading from disk and GAC — ReflectionBasedDbFactory falls back to loading provider assemblies from the file system and the GAC. Both mechanisms are completely unavailable in NativeAOT.

5. ValidationContext in the expression validator — DefaultMigrationExpressionValidator relies on System.ComponentModel.DataAnnotations, which is not trimming-safe.

What We Changed

New Abstractions

New APIs

Usage examples

Default (reflection-based, not AOT-safe) — unchanged:

// Discovers migrations from assemblies at runtime.
// Produces an IL2026 warning in trimmed builds.
services.AddFluentMigratorCore()
    .ConfigureRunner(rb => rb
        .AddSQLite()
        .WithGlobalConnectionString("Data Source=:memory:")
        .ScanIn(typeof(MyMigration).Assembly).For.Migrations());

AOT-safe (explicit type registration):

// No IL2026 warning. Types are known at compile time.
services.AddFluentMigratorSlim()
    .ConfigureRunner(rb => rb
        .AddSQLite()
        .WithGlobalConnectionString("Data Source=:memory:")
        .WithTypes(typeof(Migration_001_CreateUsers), typeof(Migration_002_AddEmail)));

Trimming Annotations Added

The following members now carry [RequiresUnreferencedCode] on the NET build target, correctly flagging reflection usage to the trimmer:

• IInsertDataSyntax.Row(object) / Rows(params object[]) — anonymous type reflection
• InsertDataExpressionBuilder.Row(object) / Rows(params object[])
• UpdateDataExpressionBuilder.Set(object) / Where(object)
• MigrationSource constructor (when no explicit ITypeSource is provided)
• MaintenanceLoader constructor (when no explicit ITypeSource is provided)
• AssemblySourceConventionSetAccessor
• AssemblyLoaderFromFile
• RuntimeHost.FindAssemblies() / FindAssemblies(string)
• ReflectionBasedDbFactory.TryCreateFactory() / FindAssembliesInGac()

Projects Targeting net8.0

All runner packages now target net8.0 with <IsTrimmable>true</IsTrimmable>, except FluentMigrator.Runner.Jet. The Jet provider uses System.Data.OleDb, which itself is not trimmable or NativeAOT-compatible, making a net8.0 target impractical.

Breaking Changes

1. [RequiresUnreferencedCode] on anonymous-type API methods
   Callers using Row(object anonymousType), Rows(params object[]), Set(object), Where(object) in a trimmed build will now receive an analyzer warning (IL2026). Switch to the IDictionary<string, object> overloads to avoid this.

2. MaintenanceLoader constructor signature
   An optional ITypeSource typeSource = null parameter was added. Existing DI-registered usage is unaffected; only direct instantiation (new MaintenanceLoader(...)) may need updating.

3. MigrationSource now implements IMigrationSource
   Previously, MigrationSource only implemented IFilteringMigrationSource. It now also implements IMigrationSource to support DI registrations that request the non-filtering interface.

Database Provider Support

Every provider factory uses Type.GetType("FullTypeName, AssemblyName") with a string literal. The trimmer recognises this pattern and preserves the referenced type. The TryGetInstance helper carries the necessary [DynamicallyAccessedMembers] annotation. When the provider assembly is statically referenced, this path is fully trim-safe.

The fallback paths (AppDomain scanning, file loading, GAC) are not NativeAOT-compatible, but they are already guarded by RuntimeFeature.IsDynamicCodeSupported and are skipped at runtime in an AOT context.

What Is Still Missing for Full AOT Support

1. Source generator

Consumers must manually call WithTypes(typeof(Migration1), ...). A Roslyn Incremental Generator that scans for [Migration], [Profile], and [Maintenance] attributes at compile time and emits the WithTypes call would make AOT adoption seamless.

2. Trimming-safe expression validator

DefaultMigrationExpressionValidator uses System.ComponentModel.DataAnnotations.ValidationContext, which is not trimming-safe. In a trimmed build, validation is currently skipped via a RuntimeFeature.IsDynamicCodeSupported guard. A proper attribute-based validator would restore validation in AOT builds.

3. Remaining reflection in the runner

The following areas have not yet been audited for AOT:

• MigrationRunner (activating migration instances via reflection)
• ProfileLoader
• VersionTableMetaDataAccessor
• TypeFinder and related convention helpers that use Type.GetCustomAttributes

4. Provider-specific code

Each provider's processor and generator code may contain additional reflection that has not yet been annotated. The net8.0 target and <IsTrimmable>true</IsTrimmable> are now in place; a full trimming audit per provider is still needed. The factory pattern is already correct — the remaining work is in the per-provider implementation classes.

5. AOT integration test

An end-to-end test that publishes a minimal AOT binary and runs a migration (e.g. against SQLite) is needed to validate the complete stack. NUnit does not support NativeAOT, so a test runner switch (e.g. to TUnit) is required before this can be implemented.