Add --r2r publish mode with unified stamp caching

Introduce a --r2r switch on the default run command that publishes with PublishAot=false and PublishReadyToRun=true for apps needing dynamic .NET features. Track publish mode (aot|r2r) in the shared stamp file and invalidate cached output when the requested mode does not match.

Author: kzu

readme.md

@@ -31,10 +31,23 @@ dnx go app.cs -- arg1 arg2
 dnx go app.cs /p:MyProp=true -- arg1 arg2
 ```
 
-The default mode publishes the app and then runs the resulting executable, 
+The default mode publishes the app with native AOT and then runs the resulting executable, 
 with smart up-to-date checks of every C# file used to build the app (including 
 `#include` and `#ref` directives, transitively).
 
+Use `--r2r` when your app needs more dynamic .NET features (reflection, dynamic loading, etc.) 
+that native AOT does not support, while still keeping most publish optimizations:
+
+```console
+dnx go app.cs --r2r
+
+# Pass arguments to your app
+dnx go app.cs --r2r -- arg1 arg2
+```
+
+This publishes with `/p:PublishAot=false` and `/p:PublishReadyToRun=true`. 
+An equivalent `--aot` switch is not needed since native AOT is the default for file-based apps.
+
 A dev mode is also available for faster iteration, which skips the publish step 
 and runs the app directly from the build output without the optimizations 
 applied by dotnet to published executables (i.e. AOT, RID-specific optimizations):

src/Tests/GoArgsTests.cs

@@ -39,4 +39,20 @@ public void Split_with_leading_separator_leaves_dotnet_args_empty()
         Assert.Empty(dotnet);
         Assert.Equal(["arg1"], app);
     }
+
+    [Fact]
+    public void ApplyPublishMode_adds_r2r_properties_when_enabled()
+    {
+        var args = GoArgs.ApplyPublishMode(["-c", "Release"], readyToRun: true);
+
+        Assert.Equal(["/p:PublishAot=false", "/p:PublishReadyToRun=true", "-c", "Release"], args);
+    }
+
+    [Fact]
+    public void ApplyPublishMode_leaves_args_unchanged_when_disabled()
+    {
+        var args = GoArgs.ApplyPublishMode(["-c", "Release"], readyToRun: false);
+
+        Assert.Equal(["-c", "Release"], args);
+    }
 }

src/Tests/GoBuildCacheTests.cs

@@ -56,6 +56,34 @@ public void IsUpToDate_works_with_bin_artifact()
         Assert.True(BuildManager.IsUpToDate(state, bin));
     }
 
+    [Fact]
+    public void IsUpToDate_returns_false_when_mode_mismatches()
+    {
+        var dir = CreateTempDir();
+        var input = WriteFile(dir, "input.cs", "input");
+        var app = WriteFile(dir, "app.exe", "app");
+        File.SetLastWriteTimeUtc(input, DateTime.UtcNow.AddMinutes(-5));
+        File.SetLastWriteTimeUtc(app, DateTime.UtcNow);
+
+        var state = new BuildState(app, null, [input], PublishMode.Aot);
+
+        Assert.False(BuildManager.IsUpToDate(state, app, PublishMode.R2r));
+    }
+
+    [Fact]
+    public void IsUpToDate_returns_true_when_mode_matches()
+    {
+        var dir = CreateTempDir();
+        var input = WriteFile(dir, "input.cs", "input");
+        var app = WriteFile(dir, "app.exe", "app");
+        File.SetLastWriteTimeUtc(input, DateTime.UtcNow.AddMinutes(-5));
+        File.SetLastWriteTimeUtc(app, DateTime.UtcNow);
+
+        var state = new BuildState(app, null, [input], PublishMode.R2r);
+
+        Assert.True(BuildManager.IsUpToDate(state, app, PublishMode.R2r));
+    }
+
     static string CreateTempDir()
     {
         var dir = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));

src/Tests/GoConfigReaderTests.cs

@@ -130,6 +130,48 @@ public void TryRead_returns_false_when_no_inputs()
         Assert.Null(state);
     }
 
+    [Fact]
+    public void TryRead_defaults_mode_to_aot_when_missing()
+    {
+        var dir = CreateTempDir();
+        var input = WriteFile(dir, "app.cs", "app");
+        var stampPath = Path.Combine(dir, "app.stamp");
+
+        File.WriteAllText(stampPath, $"""
+            input = {ToStampPath(input)}
+            """);
+
+        var success = BuildState.TryRead(stampPath, out var state);
+
+        Assert.True(success);
+        Assert.Equal(PublishMode.Aot, state!.Mode);
+    }
+
+    [Fact]
+    public void InitialContent_writes_mode_up_front()
+    {
+        Assert.Equal("mode=aot" + Environment.NewLine, BuildState.InitialContent(PublishMode.Aot));
+        Assert.Equal("mode=r2r" + Environment.NewLine, BuildState.InitialContent(PublishMode.R2r));
+    }
+
+    [Fact]
+    public void TryRead_parses_mode_r2r()
+    {
+        var dir = CreateTempDir();
+        var input = WriteFile(dir, "app.cs", "app");
+        var stampPath = Path.Combine(dir, "app.stamp");
+
+        File.WriteAllText(stampPath, $"""
+            mode = r2r
+            input = {ToStampPath(input)}
+            """);
+
+        var success = BuildState.TryRead(stampPath, out var state);
+
+        Assert.True(success);
+        Assert.Equal(PublishMode.R2r, state!.Mode);
+    }
+
     static string CreateTempDir()
     {
         var dir = Path.Combine(Path.GetTempPath(), "go-tests-" + Guid.NewGuid().ToString("N"));

src/go/BuildManager.cs

@@ -2,8 +2,17 @@
 
 namespace Devlooped;
 
-public record BuildState(string? App, string? Bin, IReadOnlyList<string> Inputs)
+public enum PublishMode
 {
+    Aot,
+    R2r,
+}
+
+public record BuildState(string? App, string? Bin, IReadOnlyList<string> Inputs, PublishMode Mode = PublishMode.Aot)
+{
+    public static string InitialContent(PublishMode mode)
+        => $"mode={mode.ToString().ToLowerInvariant()}{Environment.NewLine}";
+
     public static bool TryRead(string path, [NotNullWhen(true)] out BuildState? state)
     {
         state = null;
@@ -13,6 +22,7 @@ public static bool TryRead(string path, [NotNullWhen(true)] out BuildState? stat
         string? app = null;
         string? bin = null;
         var inputs = new List<string>();
+        var mode = PublishMode.Aot;
 
         foreach (var line in File.ReadLines(path))
         {
@@ -33,20 +43,43 @@ public static bool TryRead(string path, [NotNullWhen(true)] out BuildState? stat
                 bin = value;
             else if (key == "input")
                 inputs.Add(value);
+            else if (key == "mode" && TryParseMode(value, out var parsedMode))
+                mode = parsedMode;
         }
 
         if (inputs.Count == 0)
             return false;
 
-        state = new BuildState(app, bin, inputs);
+        state = new BuildState(app, bin, inputs, mode);
         return true;
     }
+
+    static bool TryParseMode(string value, out PublishMode mode)
+    {
+        if (value.Equals("r2r", StringComparison.OrdinalIgnoreCase))
+        {
+            mode = PublishMode.R2r;
+            return true;
+        }
+
+        if (value.Equals("aot", StringComparison.OrdinalIgnoreCase))
+        {
+            mode = PublishMode.Aot;
+            return true;
+        }
+
+        mode = default;
+        return false;
+    }
 }
 
 public static class BuildManager
 {
-    public static bool IsUpToDate(BuildState state, string artifact)
+    public static bool IsUpToDate(BuildState state, string artifact, PublishMode mode = PublishMode.Aot)
     {
+        if (state.Mode != mode)
+            return false;
+
         if (string.IsNullOrWhiteSpace(artifact) || !File.Exists(artifact))
             return false;
 

src/go/GoArgs.cs

@@ -2,6 +2,8 @@ namespace Devlooped;
 
 public static class GoArgs
 {
+    public static readonly string[] ReadyToRunPublishArgs = ["/p:PublishAot=false", "/p:PublishReadyToRun=true"];
+
     public static (string[] Dotnet, string[] App) Split(string[] extraArgs)
     {
         var separator = Array.IndexOf(extraArgs, "--");
@@ -13,4 +15,7 @@ [.. extraArgs.AsSpan(0, separator)],
             [.. extraArgs.AsSpan(separator + 1)]
         );
     }
+
+    public static string[] ApplyPublishMode(string[] dotnetArgs, bool readyToRun)
+        => readyToRun ? [.. ReadyToRunPublishArgs, .. dotnetArgs] : dotnetArgs;
 }

src/go/Program.cs

@@ -11,22 +11,23 @@
 /// Runs a file-based .NET app from a .cs entrypoint.
 /// </summary>
 /// <param name="input">Path to an existing .cs file.</param>
+/// <param name="r2r">Publish with ReadyToRun instead of native AOT; supports more dynamic .NET features while keeping most publish optimizations.</param>
 /// <param name="extraArgs">Arguments before '--' are passed to 'dotnet publish'; arguments after '--' are forwarded to the published app. Without '--', all extra arguments are forwarded to the published app.
 /// </param>
-static async Task<int> RunAsync([Argument] string input, [Argument] params string[] extraArgs)
+static async Task<int> RunAsync([Argument] string input, bool r2r = false, [Argument] params string[] extraArgs)
 {
-    var context = Prepare(input, extraArgs);
+    var context = Prepare(input, extraArgs, r2r);
     if (context is null)
         return 1;
 
-    var (dotnet, cs, stamp, targets, dotnetArgs, appArgs) = context.Value;
+    var (dotnet, cs, stamp, targets, mode, dotnetArgs, appArgs) = context.Value;
 
     if (BuildState.TryRead(stamp, out var state) &&
         state.App is not null &&
-        BuildManager.IsUpToDate(state, state.App))
+        BuildManager.IsUpToDate(state, state.App, mode))
         return await ProcessRunner.RunAsync(state.App, appArgs);
 
-    File.WriteAllText(stamp, string.Empty, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
+    File.WriteAllText(stamp, BuildState.InitialContent(mode), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
 
     var exit = await ProcessRunner.PublishAsync(dotnet, cs, stamp, targets, dotnetArgs);
     if (exit != 0)
@@ -53,7 +54,7 @@ static async Task<int> DevAsync([Argument] string input, [Argument] params strin
     if (context is null)
         return 1;
 
-    var (dotnet, cs, stamp, targets, dotnetArgs, appArgs) = context.Value;
+    var (dotnet, cs, stamp, targets, _, dotnetArgs, appArgs) = context.Value;
 
     if (BuildState.TryRead(stamp, out var state) &&
         state.Bin is not null &&
@@ -65,7 +66,7 @@ state.Bin is not null &&
     return await ProcessRunner.DotnetRunAsync(dotnet, cs, stamp, targets, dotnetArgs, appArgs);
 }
 
-static (string Dotnet, string Cs, string Stamp, string Targets, string[] DotnetArgs, string[] AppArgs)? Prepare(string input, string[] extraArgs)
+static (string Dotnet, string Cs, string Stamp, string Targets, PublishMode Mode, string[] DotnetArgs, string[] AppArgs)? Prepare(string input, string[] extraArgs, bool readyToRun = false)
 {
     var dotnet = DotnetMuxer.Path?.FullName;
     if (dotnet is null)
@@ -82,8 +83,10 @@ state.Bin is not null &&
     }
 
     var (dotnetArgs, appArgs) = GoArgs.Split(extraArgs);
+    var mode = readyToRun ? PublishMode.R2r : PublishMode.Aot;
+    dotnetArgs = GoArgs.ApplyPublishMode(dotnetArgs, readyToRun);
     var stamp = Path.ChangeExtension(cs, "stamp");
     var targets = Path.Combine(AppContext.BaseDirectory, "go.targets");
 
-    return (dotnet, cs, stamp, targets, dotnetArgs, appArgs);
+    return (dotnet, cs, stamp, targets, mode, dotnetArgs, appArgs);
 }

src/go/help.md

@@ -1,12 +1,15 @@
 ```shell
-Usage: [command] [arguments...] [-h|--help] [--version]
+Usage: [command] [arguments...] [options...] [-h|--help] [--version]
 
 Runs a file-based .NET app from a .cs entrypoint.
 
 Arguments:
   [0] <string>      Path to an existing .cs file.
   [1] <string[]>    Arguments before '--' are passed to 'dotnet publish'; arguments after '--' are forwarded to the published app. Without '--', all extra arguments are forwarded to the published app.
 
+Options:
+  --r2r    Publish with ReadyToRun instead of native AOT; supports more dynamic .NET features while keeping most publish optimizations.
+
 Commands:
   dev    Runs a file-based .NET app from a .cs entrypoint using dotnet run for fast iteration.
 ```