Add NativeAOT and trimming support

.github/workflows/codeql-analysis.yml

@@ -22,6 +22,9 @@ jobs:
           # We must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head.
           fetch-depth: 2
+          # The NativeAOT test application copies test databases out of this
+          # submodule, so autobuild cannot compile the solution without it.
+          submodules: true
           persist-credentials: false
 
       # If this run was triggered by a pull request event, then checkout

.github/workflows/test.yml

@@ -39,8 +39,43 @@ jobs:
           MAXMIND_BENCHMARK_DB:
             ${{ github.workspace
             }}/MaxMind.Db.Test/TestData/MaxMind-DB/test-data/GeoIP2-City-Test.mmdb
+          # Without this the benchmark falls back to 1,000 pseudo-random addresses,
+          # which all miss in this 26-record database: no record is found, no model
+          # is ever constructed, and it reports zero allocations. These addresses
+          # hit, so the decode path is actually measured.
+          MAXMIND_BENCHMARK_IP_ADDRESSES: 2.125.160.216,67.43.156.1,81.2.69.142,81.2.69.144,81.2.69.160,89.160.20.112,89.160.20.128,149.101.100.1,175.16.199.1,202.196.224.1,216.160.83.56,216.160.83.61
 
       - name: Run tests
         run: dotnet test
         env:
           MAXMIND_TEST_BASE_DIR: ${{ github.workspace }}/MaxMind.Db.Test
+
+  native-aot:
+    strategy:
+      matrix:
+        include:
+          - platform: ubuntu-latest
+            rid: linux-x64
+          - platform: windows-latest
+            rid: win-x64
+          - platform: macos-latest
+            rid: osx-arm64
+    runs-on: ${{ matrix.platform }}
+    name: NativeAOT on ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          submodules: true
+          persist-credentials: false
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0
+        with:
+          dotnet-version: |
+            8.0.x
+            9.0.x
+            10.0.x
+
+      - name: Publish and run NativeAOT integration tests
+        shell: bash
+        run: bash ./dev-bin/test-native-aot.sh ${{ matrix.rid }}

.markdownlint-cli2.jsonc

@@ -0,0 +1,3 @@
+{
+  "ignores": ["MaxMind.Db.SourceGenerator/AnalyzerReleases.*.md"]
+}

.prettierignore

@@ -0,0 +1 @@
+MaxMind.Db.SourceGenerator/AnalyzerReleases.*.md

MaxMind.Db.Benchmark/MaxMind.Db.Benchmark.csproj

@@ -32,6 +32,9 @@
 
   <ItemGroup>
     <ProjectReference Include="..\MaxMind.Db\MaxMind.Db.csproj" />
+    <ProjectReference Include="..\MaxMind.Db.SourceGenerator\MaxMind.Db.SourceGenerator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false" />
   </ItemGroup>
 
   <ItemGroup>

MaxMind.Db.NativeAot/App/MaxMind.Db.NativeAot.App.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <PublishAot>true</PublishAot>
+    <PublishTrimmed>true</PublishTrimmed>
+    <TrimMode>full</TrimMode>
+    <ILLinkTreatWarningsAsErrors>true</ILLinkTreatWarningsAsErrors>
+    <TrimmerSingleWarn>false</TrimmerSingleWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Models\MaxMind.Db.NativeAot.Models.csproj" />
+    <ProjectReference Include="..\..\MaxMind.Db.NetStandard.TestModels\MaxMind.Db.NetStandard.TestModels.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\..\MaxMind.Db.Test\TestData\MaxMind-DB\test-data\GeoIP2-City-Test.mmdb"
+          Link="GeoIP2-City-Test.mmdb"
+          CopyToOutputDirectory="PreserveNewest"
+          CopyToPublishDirectory="PreserveNewest" />
+    <None Include="..\..\MaxMind.Db.Test\TestData\MaxMind-DB\test-data\MaxMind-DB-test-decoder.mmdb"
+          Link="MaxMind-DB-test-decoder.mmdb"
+          CopyToOutputDirectory="PreserveNewest"
+          CopyToPublishDirectory="PreserveNewest" />
+  </ItemGroup>
+
+</Project>

MaxMind.Db.NativeAot/App/Program.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Runtime.CompilerServices;
+using MaxMind.Db;
+using MaxMind.Db.NativeAot.Models;
+using MaxMind.Db.NetStandard.TestModels;
+
+namespace MaxMind.Db.NativeAot.App
+{
+    internal static class Program
+    {
+        private static readonly IPAddress _decoderAddress = IPAddress.Parse("1.1.1.1");
+        private static readonly IPAddress _cityAddress = IPAddress.Parse("81.2.69.160");
+
+        private static void Main()
+        {
+            Check(!RuntimeFeature.IsDynamicCodeSupported, "The integration test must run as NativeAOT.");
+            Check(
+                typeof(CityResponse).Assembly != typeof(Reader).Assembly,
+                "Models must be generated in a separate assembly.");
+
+            foreach (var mode in new[] { FileAccessMode.MemoryMapped, FileAccessMode.Memory })
+            {
+                TestDecoderDatabase(mode);
+                TestCityDatabase(mode);
+                TestReflectionFallbackFailsWithGuidance(mode);
+            }
+
+            Console.WriteLine("NativeAOT integration tests passed.");
+        }
+
+        private static void TestDecoderDatabase(FileAccessMode mode)
+        {
+            var database = Path.Combine(AppContext.BaseDirectory, "MaxMind-DB-test-decoder.mmdb");
+            using var reader = new Reader(database, mode);
+
+            Check(reader.Metadata.DatabaseType == "MaxMind DB Decoder Test", "Unexpected metadata.");
+
+            var dictionary = reader.Find<Dictionary<string, object>>(_decoderAddress) ??
+                throw new InvalidOperationException("Dictionary lookup returned null.");
+            Check(
+                (string)dictionary["utf8_string"] == "unicode! ☯ - ♫",
+                "Dictionary string did not decode.");
+
+            var concurrentDictionary =
+                reader.Find<ConcurrentDictionary<string, object>>(_decoderAddress) ??
+                throw new InvalidOperationException(
+                    "ConcurrentDictionary lookup returned null.");
+            Check(
+                (string)concurrentDictionary["utf8_string"] == "unicode! ☯ - ♫",
+                "Source-generated top-level dictionary did not decode.");
+
+            var constructorModel = reader.Find<DecoderConstructorModel>(_decoderAddress) ??
+                throw new InvalidOperationException("Constructor model lookup returned null.");
+            Check(
+                constructorModel.Utf8String == "unicode! ☯ - ♫",
+                "Constructor model string did not decode.");
+            Check(
+                SequenceEquals(constructorModel.Array, 1, 2, 3),
+                "IReadOnlyList did not decode.");
+            Check(
+                NestedStringEquals(constructorModel.Map, "hello"),
+                "IReadOnlyDictionary did not decode.");
+
+            var netStandardModel = reader.Find<NetStandardModel>(_decoderAddress) ??
+                throw new InvalidOperationException(".NET Standard model lookup returned null.");
+            Check(
+                netStandardModel.Utf8String == "unicode! ☯ - ♫",
+                ".NET Standard model did not decode.");
+
+            var propertyModel = reader.Find<DecoderPropertyModel>(_decoderAddress) ??
+                throw new InvalidOperationException("Property model lookup returned null.");
+            Check(SequenceEquals(propertyModel.Array, 1, 2, 3), "ICollection did not decode.");
+            Check(
+                NestedStringEquals(propertyModel.Map, "hello"),
+                "Dictionary did not decode.");
+
+            var concreteModel = reader.Find<DecoderConcreteCollectionModel>(_decoderAddress) ??
+                throw new InvalidOperationException("Concrete collection model lookup returned null.");
+            Check(SequenceEquals(concreteModel.Array, 1, 2, 3), "LinkedList did not decode.");
+            Check(
+                NestedStringEquals(concreteModel.Map, "hello"),
+                "Concrete dictionary did not decode.");
+
+            var count = 0;
+            foreach (var _ in reader.FindAll<DecoderConstructorModel>())
+            {
+                count++;
+            }
+            Check(count == 26, $"FindAll returned {count} records instead of 26.");
+        }
+
+        private static void TestCityDatabase(FileAccessMode mode)
+        {
+            var database = Path.Combine(AppContext.BaseDirectory, "GeoIP2-City-Test.mmdb");
+            var injectables = new InjectableValues();
+            injectables.AddValue("locales", (IReadOnlyList<string>)["en"]);
+            using var reader = new Reader(database, mode);
+
+            var response = reader.Find<CityResponse>(_cityAddress, injectables) ??
+                throw new InvalidOperationException("City lookup returned null.");
+            Check(response.City.Name == "London", "City name did not decode.");
+            Check(response.Subdivisions.Count == 1, "Subdivisions did not decode.");
+            Check(
+                response.Subdivisions[0].Name == "England",
+                "Subdivision name did not decode.");
+            Check(
+                response.Traits.Network?.ToString() == "81.2.69.160/27",
+                "Network did not decode.");
+        }
+
+        // ReflectionFallbackModel has no generated registration, so this is the only
+        // coverage of what the reflection fallback does once trimmed and published as
+        // NativeAOT; no analyzer reports that path. Full trimming removes the members
+        // reflection needs, so the lookup fails before Expression.Compile is ever
+        // reached. What matters is that the failure stays actionable.
+        private static void TestReflectionFallbackFailsWithGuidance(FileAccessMode mode)
+        {
+            var database = Path.Combine(AppContext.BaseDirectory, "MaxMind-DB-test-decoder.mmdb");
+            using var reader = new Reader(database, mode);
+
+            try
+            {
+                reader.Find<ReflectionFallbackModel>(_decoderAddress);
+            }
+            catch (DeserializationException ex)
+            {
+                Check(
+                    ex.Message.Contains(nameof(ReflectionFallbackModel)),
+                    "The fallback failure must name the model.");
+                Check(
+                    ex.Message.Contains("rebuild the assembly that declares the model"),
+                    "The fallback failure must point at the source generator.");
+                return;
+            }
+
+            throw new InvalidOperationException(
+                "Decoding a model without a generated registration must fail once trimmed.");
+        }
+
+        private static bool SequenceEquals(IEnumerable<long> values, params long[] expected)
+        {
+            var index = 0;
+            foreach (var value in values)
+            {
+                if (index >= expected.Length || value != expected[index])
+                {
+                    return false;
+                }
+                index++;
+            }
+            return index == expected.Length;
+        }
+
+        private static bool NestedStringEquals(
+            IReadOnlyDictionary<string, object> map,
+            string expected
+            )
+            => map.TryGetValue("mapX", out var nested) &&
+                nested is IReadOnlyDictionary<string, object> inner &&
+                inner.TryGetValue("utf8_stringX", out var value) &&
+                (value as string) == expected;
+
+        private static void Check(bool condition, string message)
+        {
+            if (!condition)
+            {
+                throw new InvalidOperationException(message);
+            }
+        }
+    }
+}

MaxMind.Db.NativeAot/Directory.Build.props

@@ -0,0 +1,32 @@
+<Project>
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>14.0</LangVersion>
+    <Nullable>enable</Nullable>
+    <IsAotCompatible>true</IsAotCompatible>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <AnalysisLevel>latest</AnalysisLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(MaxMindDbPackageVersion)' != ''">
+    <PackageReference Include="MaxMind.Db" Version="$(MaxMindDbPackageVersion)" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(MaxMindDbPackageVersion)' == ''">
+    <ProjectReference Include="$(MSBuildThisFileDirectory)..\MaxMind.Db\MaxMind.Db.csproj" />
+    <ProjectReference Include="$(MSBuildThisFileDirectory)..\MaxMind.Db.SourceGenerator\MaxMind.Db.SourceGenerator.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false"
+                      PrivateAssets="all" />
+  </ItemGroup>
+
+  <Target Name="VerifyMaxMindDbAotDiagnostics"
+          BeforeTargets="CoreCompile"
+          Condition="'$(MaxMindDbPackageVersion)' != '' and '$(MaxMindDbAotDiagnostics)' != 'true'">
+    <Error Text="The packaged MaxMind.Db analyzer did not enable NativeAOT diagnostics for $(MSBuildProjectName)." />
+  </Target>
+
+</Project>

MaxMind.Db.NativeAot/Models/MaxMind.Db.NativeAot.Models.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <!-- Written out so VerifyMaxMindDbGeneratedRegistrations can confirm the
+         generator ran. The App consumes a packed MaxMind.Db, so this is what
+         catches the analyzer going missing from the package. -->
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+
+  <Target Name="VerifyMaxMindDbGeneratedRegistrations" AfterTargets="CoreCompile">
+    <ItemGroup>
+      <MaxMindDbGeneratedRegistration
+        Include="$(IntermediateOutputPath)generated/**/MaxMind.Db.SourceGenerator.g.cs" />
+    </ItemGroup>
+    <Error Condition="'@(MaxMindDbGeneratedRegistration)' == ''"
+           Text="The MaxMind.Db source generator produced no registrations for $(MSBuildProjectName). Every model in this assembly would fall back to reflection, which is unsupported after trimming or with NativeAOT." />
+  </Target>
+
+</Project>