Label inline patches with the project's framework, not the runner's

RuntimeMoniker read AppContext.TargetFrameworkName, which is the entry
assembly's TargetFrameworkAttribute. In a hosted test run the entry
assembly is the runner - testhost is net8.0, ReSharperTestRunner is
netcoreapp3.0 - so every leg of a multi-targeted run stamped the
runner's one moniker, and the queue could neither keep the legs'
variants apart nor settle one without the other.

buildTransitive/DiffEngine.targets now stamps the consuming project's
own $(TargetFramework) into its runtimeconfig, per leg, the same way
the bundled viewer path already travels. RuntimeMoniker reads that
first and falls back to the running runtime's version for consumers
without the targets. .NET Framework keeps the attribute path: it has
no runtimeconfig to carry a stamp, and every net4x moniker runs on the
one CLR.

The tests project stamps itself the way a consumer's build does, so
the suite runs the configured path end to end, and BuildTargetsTests
ties the targets XML to the C# constants reading it.

Author: SimonCropp

.gitignore

@@ -13,3 +13,4 @@ nul
 /coverage
 BenchmarkDotNet.Artifacts/
 native/build/
+/src/TestResults

docs/inline.md

@@ -77,7 +77,7 @@ For the producing side — a test library with a failing inline snapshot:
 
 * `DiffRunner.AddInlineAsync(patch)` queues a patch with whatever owns the port, launching the bundled viewer when nothing does. Returns `Queued`, `Disabled` (build servers, continuous testing and AI CLIs included), or `NoViewerFound` — the caller's cue to stage files and fall back to a text diff.
 * `DiffRunner.SettleInline(sourceFile, line)` drops the pending entry for a call site, for when a previously failing test passes. Unknown entries and an absent owner are no-ops, so call it freely. The settle carries the running framework, so a multi-targeted run only settles its own variant of a conflicted entry.
-* `AddInlineAsync` stamps `patch.Framework` with the running process's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
+* `AddInlineAsync` stamps `patch.Framework` with the consuming project's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. The value is the `$(TargetFramework)` the package's build targets stamp into the project's runtimeconfig, read back rather than asked of the process — in a hosted test run the entry assembly is the runner (testhost, ReSharperTestRunner), whose framework is not the project's — with the running runtime's version as the fallback for consumers without the targets. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
 * Set `patch.OriginalExpression` from `CallerArgumentExpression` where the language supplies one, and `patch.OriginalValue` — the previous expected argument's value — where it does not. One of the two is what stops a patch rewriting the wrong call site when the file has moved since the run. `patch.MemberName` from `CallerMemberName` narrows it further, and is supported everywhere including F#.
 * Setting `DiffEngine_InlineViewer` to `false` reports `NoViewerFound` without probing, which is how a user opts into reviewing in their IDE instead of a window.
 

docs/mdsource/inline.source.md

@@ -70,7 +70,7 @@ For the producing side — a test library with a failing inline snapshot:
 
 * `DiffRunner.AddInlineAsync(patch)` queues a patch with whatever owns the port, launching the bundled viewer when nothing does. Returns `Queued`, `Disabled` (build servers, continuous testing and AI CLIs included), or `NoViewerFound` — the caller's cue to stage files and fall back to a text diff.
 * `DiffRunner.SettleInline(sourceFile, line)` drops the pending entry for a call site, for when a previously failing test passes. Unknown entries and an absent owner are no-ops, so call it freely. The settle carries the running framework, so a multi-targeted run only settles its own variant of a conflicted entry.
-* `AddInlineAsync` stamps `patch.Framework` with the running process's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
+* `AddInlineAsync` stamps `patch.Framework` with the consuming project's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. The value is the `$(TargetFramework)` the package's build targets stamp into the project's runtimeconfig, read back rather than asked of the process — in a hosted test run the entry assembly is the runner (testhost, ReSharperTestRunner), whose framework is not the project's — with the running runtime's version as the fallback for consumers without the targets. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
 * Set `patch.OriginalExpression` from `CallerArgumentExpression` where the language supplies one, and `patch.OriginalValue` — the previous expected argument's value — where it does not. One of the two is what stops a patch rewriting the wrong call site when the file has moved since the run. `patch.MemberName` from `CallerMemberName` narrows it further, and is supported everywhere including F#.
 * Setting `DiffEngine_InlineViewer` to `false` reports `NoViewerFound` without probing, which is how a user opts into reviewing in their IDE instead of a window.
 

src/DiffEngine.Tests/BuildTargetsTests.cs

@@ -0,0 +1,16 @@
+/// <summary>
+/// buildTransitive/DiffEngine.targets writes values that C# constants read back, and nothing
+/// else holds the two halves together: a key renamed in one place would not fail to compile, it
+/// would silently stop the stamp arriving. The targets file is linked into the test output, so
+/// this runs from source rather than from a packed nupkg.
+/// </summary>
+public class BuildTargetsTests
+{
+    [Test]
+    public async Task CarriesTheKeysTheLibraryReads()
+    {
+        var targets = await File.ReadAllTextAsync(Path.Combine(AppContext.BaseDirectory, "DiffEngine.targets"));
+        await Assert.That(targets).Contains(RuntimeMoniker.Key);
+        await Assert.That(targets).Contains(BundledViewerDirectory.Key);
+    }
+}

src/DiffEngine.Tests/DiffEngine.Tests.csproj

@@ -13,6 +13,11 @@
     <PackageReference Include="Argon" />
     <PackageReference Include="ProjectDefaults" PrivateAssets="all" />
     <ProjectReference Include="..\DiffEngine\DiffEngine.csproj" />
+    <!-- The stamp consumers get from buildTransitive/DiffEngine.targets, so the suite runs the
+         configured RuntimeMoniker path rather than only its fallback. -->
+    <RuntimeHostConfigurationOption Include="DiffEngine.TargetFramework" Value="$(TargetFramework)" />
+    <!-- For BuildTargetsTests, which ties the targets XML to the C# constants reading it. -->
+    <None Include="..\DiffEngine\buildTransitive\DiffEngine.targets" Link="DiffEngine.targets" CopyToOutputDirectory="PreserveNewest" />
     <Compile Remove="DefinitionsTest.cs" Condition="'$(TargetFramework)' == 'net9.0'" />
     <PackageReference Include="TUnit" />
     <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" />

src/DiffEngine.Tests/RuntimeMonikerTests.cs

@@ -24,9 +24,23 @@ public async Task Maps(string frameworkName, string expected) =>
     public async Task UnknownIsNull(string? frameworkName) =>
         await Assert.That(RuntimeMoniker.Map(frameworkName)).IsNull();
 
+#if !NETFRAMEWORK
+    /// <summary>
+    /// The tests project stamps DiffEngine.TargetFramework the way the shipped targets stamp a
+    /// consumer, so this asserts the whole configured path: MSBuild item to runtimeconfig to
+    /// AppContext. Without the stamp the suite would only ever run the runtime-version fallback,
+    /// and a broken key would not fail anything.
+    /// </summary>
+    [Test]
+    public async Task StampReachesAppContext() =>
+        await Assert.That(AppContext.GetData(RuntimeMoniker.Key)).IsEqualTo("net10.0");
+#endif
+
     /// <summary>
     /// Runs on both test frameworks, so both socket-era families pin their own moniker. The
-    /// .NET Framework side only asserts the family: the exact minor is the test host's business.
+    /// .NET Core side takes the configured path, since the csproj stamps the key the way a
+    /// consumer's build does; the .NET Framework side only asserts the family, because the exact
+    /// minor is the test host's business.
     /// </summary>
     [Test]
     public async Task CurrentMatchesThisRuntime() =>

src/DiffEngine/Inline/RuntimeMoniker.cs

@@ -4,12 +4,35 @@
 /// </summary>
 static class RuntimeMoniker
 {
+    public const string Key = "DiffEngine.TargetFramework";
+
     /// <summary>
-    /// Null when the framework cannot be determined, which downstream treats as an unlabeled
-    /// origin rather than guessing.
+    /// The consuming project's own $(TargetFramework) when buildTransitive/DiffEngine.targets
+    /// stamped it into the runtimeconfig, otherwise the version of the runtime actually
+    /// executing. Never AppContext.TargetFrameworkName: that is the entry assembly's
+    /// TargetFrameworkAttribute, and in a hosted test run the entry assembly is the runner -
+    /// testhost is net8.0, ReSharperTestRunner is netcoreapp3.0 - so every leg of a
+    /// multi-targeted run stamped the runner's one moniker, and the queue could neither keep the
+    /// legs' variants apart nor settle one without the other. The runtime fallback covers
+    /// consumers without the targets, such as linked-source builds: each leg launches on its own
+    /// runtime, so it still tells apart what the label exists to tell apart, at the cost of
+    /// naming the rolled-forward runtime rather than the target.
+    /// <para>
+    /// .NET Framework keeps the attribute path, and with it null when nothing can be determined:
+    /// it has no runtimeconfig to carry a stamp, its Environment.Version is the CLR's own
+    /// (4.0.30319) whatever the target, and every net4x moniker runs on that one CLR.
+    /// </para>
     /// </summary>
-    public static string? Current { get; } = Map(FrameworkName());
+    public static string? Current { get; } =
+#if NETFRAMEWORK
+        Map(FrameworkName());
+#else
+        AppContext.GetData(Key) is string { Length: > 0 } configured
+            ? configured
+            : $"net{Environment.Version.Major}.{Environment.Version.Minor}";
+#endif
 
+#if NETFRAMEWORK
     static string? FrameworkName() =>
 #if NET462
         // AppContext.TargetFrameworkName arrived in 4.7.1; this is what it reads there anyway.
@@ -18,6 +41,7 @@ static class RuntimeMoniker
         AppContext.TargetFrameworkName ??
 #endif
         Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
+#endif
 
     // Internal seam for tests; the input shape is "{identifier},Version=v{version}[,Profile=...]".
     internal static string? Map(string? frameworkName)

src/DiffEngine/buildTransitive/DiffEngine.targets

@@ -31,4 +31,18 @@
     </AssemblyAttribute>
   </ItemGroup>
 
+  <!--
+  The consuming project's own target framework, one stamp per multi-target leg. RuntimeMoniker
+  prefers this over anything the process can tell it: in a hosted test run the entry assembly is
+  the runner - testhost, ReSharperTestRunner - compiled for its own framework rather than the
+  project's, so every leg of a multi-targeted run would otherwise carry the same label. Not
+  mirrored into assembly metadata for .NET Framework the way the viewer path is: metadata lands
+  on every stamped assembly, class libraries included, so a reader could not tell the test
+  project's stamp from a dependency's.
+  -->
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="DiffEngine.TargetFramework"
+                                    Value="$(TargetFramework)" />
+  </ItemGroup>
+
 </Project>