Address PR review: fix AOT warning fixture comments and harden per-API check.

Author: tillig

default.proj

@@ -100,15 +100,25 @@
     fails. Unlike VerifyAot proper, this needs no native toolchain - a plain build
     surfaces the analyzer diagnostics - so it is cheap to run anywhere.
 
-    Keep ExpectedAotWarningCodes in sync with the diagnostics produced by
-    test/Autofac.Test.AotWarnings/Program.cs.
+    The check is PER CALL SITE, not just per diagnostic code: each ExpectedAotWarning
+    item names both the code (IL2026/IL3050) and a distinctive substring of the
+    annotated member's signature as it appears in the warning text. Multiple call
+    sites share a code (e.g. RegisterGeneric and RegisterGenericDecorator are both
+    IL3050), so asserting only "IL3050 appears somewhere" would not catch losing the
+    annotation on just one of them. Matching the member signature catches each one.
+
+    Keep the ExpectedAotWarning items in sync with the calls in
+    test/Autofac.Test.AotWarnings/Program.cs - one item per annotated call.
   -->
   <PropertyGroup>
     <AotWarningsProjectDirectory>$([System.IO.Path]::Combine($(MSBuildProjectDirectory),'test/Autofac.Test.AotWarnings'))</AotWarningsProjectDirectory>
   </PropertyGroup>
   <ItemGroup>
-    <ExpectedAotWarningCode Include="IL3050" />
-    <ExpectedAotWarningCode Include="IL2026" />
+    <!-- Identity = the IL code; Member = a substring uniquely identifying the API in the warning text. -->
+    <ExpectedAotWarning Include="IL3050" Member="RegisterGeneric(ContainerBuilder, Type)" />
+    <ExpectedAotWarning Include="IL3050" Member="RegisterGenericDecorator(ContainerBuilder, Type, Type" />
+    <ExpectedAotWarning Include="IL2026" Member="RegisterAssemblyTypes(ContainerBuilder, params Assembly" />
+    <ExpectedAotWarning Include="IL2026" Member="RegisterAssemblyModules(ContainerBuilder, params Assembly" />
   </ItemGroup>
   <Target Name="VerifyAotWarnings">
     <Message Text="****************************************" Importance="high" />
@@ -123,8 +133,9 @@
     <PropertyGroup>
       <AotWarningsBuildText>@(AotWarningsBuildOutput, '%0a')</AotWarningsBuildText>
     </PropertyGroup>
-    <Error Condition="!$(AotWarningsBuildText.Contains('warning %(ExpectedAotWarningCode.Identity)'))"
-           Text="Expected AOT/trim diagnostic %(ExpectedAotWarningCode.Identity) was NOT emitted by Autofac.Test.AotWarnings. A [RequiresDynamicCode]/[RequiresUnreferencedCode] annotation may have been lost in core Autofac." />
-    <Message Text="All expected AOT/trim warnings (@(ExpectedAotWarningCode, ', ')) were emitted." Importance="high" />
+    <!-- Each expected warning must appear with BOTH its code and the specific member signature. -->
+    <Error Condition="!($(AotWarningsBuildText.Contains('warning %(ExpectedAotWarning.Identity)')) and $(AotWarningsBuildText.Contains('%(ExpectedAotWarning.Member)')))"
+           Text="Expected AOT/trim diagnostic %(ExpectedAotWarning.Identity) for '%(ExpectedAotWarning.Member)' was NOT emitted by Autofac.Test.AotWarnings. A [RequiresDynamicCode]/[RequiresUnreferencedCode] annotation may have been lost in core Autofac." />
+    <Message Text="All expected AOT/trim warnings were emitted (@(ExpectedAotWarning->'%(Identity): %(Member)', '; '))." Importance="high" />
   </Target>
 </Project>

test/Autofac.Test.Aot/Program.cs

@@ -136,7 +136,11 @@ public static int Main()
         // --- Scenarios that MUST throw under Native AOT (dynamic-code boundary) ---
 
         // Closing an open generic over a VALUE type requires MakeGenericType over a
-        // value type, which Native AOT cannot generate.
+        // value type, which Native AOT cannot generate. This assertion is deliberately
+        // runtime/environment sensitive: if a future runtime adds universal shared
+        // generics for value types, this could start SUCCEEDING and fail the check.
+        // That is by design - a failure here likely means "the AOT boundary moved"
+        // (update this test and the AOT docs), not "Autofac is broken".
         CheckThrows(failures, "Resolve IGenericHolder<int> (value-type close)", () => container.Resolve<IGenericHolder<int>>());
 
         if (failures.Count > 0)

test/Autofac.Test.AotWarnings/Autofac.Test.AotWarnings.csproj

@@ -2,22 +2,23 @@
   <!--
     AOT/trim WARNING fixture.
 
-    This project's job is to FAIL TO BUILD. It calls the Autofac APIs that are
-    annotated [RequiresDynamicCode] / [RequiresUnreferencedCode], with
-    IsAotCompatible=true (which turns on the trim/AOT analyzers) and
-    TreatWarningsAsErrors=true, so the analyzer diagnostics become build errors.
+    This project is EXPECTED TO BUILD SUCCESSFULLY and, in doing so, emit the
+    trim/AOT analyzer warnings (IL2026 / IL3050) for the Autofac APIs that are
+    annotated [RequiresUnreferencedCode] / [RequiresDynamicCode]. Setting
+    IsAotCompatible=true turns on those analyzers, and TreatWarningsAsErrors is left
+    OFF so the warnings stay warnings (and the build still succeeds).
 
-    The 'VerifyAotWarnings' target in default.proj builds this project EXPECTING
-    failure and asserts that the expected IL2026/IL3050 codes appear. That guards
+    The 'VerifyAotWarnings' target in default.proj builds this project and asserts
+    the expected IL codes appear in the (successful) build output. That guards
     against silently LOSING a [Requires*] attribute in a future refactor: if an
-    annotation is dropped, the corresponding warning stops firing, this project
-    starts building successfully, and the verification target fails.
+    annotation is dropped, the corresponding warning stops firing and the target
+    fails because an expected code is missing.
 
     Unlike the runtime smoke test (Autofac.Test.Aot) this needs no native toolchain -
     plain 'dotnet build' surfaces the analyzer diagnostics - so it runs in normal CI.
 
-    It is intentionally NOT part of Autofac.sln so the normal build does not try to
-    compile a project that is designed not to compile.
+    It is intentionally NOT part of Autofac.sln; it exists only to be built by the
+    verify target.
   -->
   <PropertyGroup>
     <OutputType>Exe</OutputType>
@@ -26,14 +27,17 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <IsPackable>false</IsPackable>
     <IsTestProject>false</IsTestProject>
+    <!-- Sign to match the rest of the repo's assemblies (and the sibling AOT test project). -->
+    <AssemblyOriginatorKeyFile>../../Autofac.snk</AssemblyOriginatorKeyFile>
+    <SignAssembly>true</SignAssembly>
     <!-- Turn on the trim/AOT analyzers so the [Requires*] diagnostics are emitted. -->
     <IsAotCompatible>true</IsAotCompatible>
     <TrimmerSingleWarn>false</TrimmerSingleWarn>
     <!--
-      This project is verified by building it and asserting it fails. Do not let a
-      stray analyzer/style rule turn into an error that masks the IL diagnostics, and
-      do not treat the deliberate IL warnings as errors here - the verify target reads
-      them from the (failed-by-design) build output instead.
+      Keep TreatWarningsAsErrors OFF: this project is supposed to build successfully
+      WITH the trim/AOT warnings present, and the verify target reads the IL codes
+      from that successful build output. Treating them as errors would fail the build
+      and there would be no output to inspect.
     -->
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <RunAnalyzers>true</RunAnalyzers>

test/Autofac.Test.AotWarnings/Program.cs

@@ -9,9 +9,13 @@
 // Each statement below calls an Autofac API that is annotated [RequiresDynamicCode]
 // or [RequiresUnreferencedCode]. With IsAotCompatible=true the trim/AOT analyzers
 // run and emit the IL codes noted in the comments. The 'VerifyAotWarnings' target in
-// default.proj builds this project and asserts those codes are present in the output;
-// if an annotation is ever lost, the corresponding warning disappears and the target
-// fails. The expected codes are duplicated in that target - keep them in sync.
+// default.proj builds this project and asserts, PER CALL SITE, that the expected
+// warning appears (matching both the IL code and the member signature - several call
+// sites share a code, so a code-only check would miss losing one of them). If an
+// annotation is ever lost, the matching warning disappears and the target fails.
+//
+// Keep these calls in sync with the ExpectedAotWarning items in default.proj - one
+// item there per annotated call here.
 var builder = new ContainerBuilder();
 
 // IL3050 (RequiresDynamicCode): open generic registration constructs closed types