dotnet tool run and install roll-forward option

src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.ToolManifest;
@@ -27,7 +28,7 @@ public LocalToolsCommandResolver(
             _fileSystem = fileSystem ?? new FileSystemWrapper();
         }
 
-        public CommandSpec ResolveStrict(CommandResolverArguments arguments)
+        public CommandSpec ResolveStrict(CommandResolverArguments arguments, bool allowRollForward = false)
         {
             if (arguments == null || string.IsNullOrWhiteSpace(arguments.CommandName))
             {
@@ -40,7 +41,7 @@ public CommandSpec ResolveStrict(CommandResolverArguments arguments)
             }
 
             var resolveResult = GetPackageCommandSpecUsingMuxer(arguments,
-                new ToolCommandName(arguments.CommandName.Substring(LeadingDotnetPrefix.Length)));
+                new ToolCommandName(arguments.CommandName.Substring(LeadingDotnetPrefix.Length)), allowRollForward);
 
             return resolveResult;
         }
@@ -73,7 +74,7 @@ public CommandSpec Resolve(CommandResolverArguments arguments)
         }
 
         private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arguments,
-            ToolCommandName toolCommandName)
+            ToolCommandName toolCommandName, bool allowRollForward = false)
         {
             if (!_toolManifest.TryFind(toolCommandName, out var toolManifestPackage))
             {
@@ -95,6 +96,11 @@ private CommandSpec GetPackageCommandSpecUsingMuxer(CommandResolverArguments arg
                         toolCommandName.ToString()));
                 }
 
+                if (toolManifestPackage.RollForward || allowRollForward)
+                {
+                    arguments.CommandArguments = ["--roll-forward", "Major", .. arguments.CommandArguments];
+                }
+
                 return MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(
                     restoredCommand.Executable.Value,
                     arguments.CommandArguments);

src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandSpecMaker.cs

@@ -11,23 +11,23 @@ internal static CommandSpec CreatePackageCommandSpecUsingMuxer(
             string commandPath,
             IEnumerable<string> commandArguments)
         {
-            var arguments = new List<string>();
-
             var muxer = new Muxer();
-
             var host = muxer.MuxerPath;
+
             if (host == null)
             {
                 throw new Exception(LocalizableStrings.UnableToLocateDotnetMultiplexer);
             }
 
-            arguments.Add(commandPath);
+            var previousArg = string.Empty;
 
-            if (commandArguments != null)
-            {
-                arguments.AddRange(commandArguments);
-            }
+            // Group the arguments by if the previous argument or the current argument is --roll-forward.
+            var argGroups = (commandArguments ?? [])
+                .GroupBy(a => previousArg.Equals("--roll-forward", StringComparison.OrdinalIgnoreCase)
+                | (previousArg = a).Equals("--roll-forward", StringComparison.OrdinalIgnoreCase))
+                .ToArray();
 
+            string[] arguments = [..argGroups.Where(g => g.Key).SelectMany(g => g), commandPath, .. argGroups.Where(g => !g.Key).SelectMany(g => g)];
             return CreateCommandSpec(host, arguments);
         }
 

src/Cli/dotnet/CommonLocalizableStrings.resx

@@ -733,4 +733,7 @@ The default is 'false.' However, when targeting .NET 7 or lower, the default is
   <data name="ArtifactsPathArgumentName" xml:space="preserve">
     <value>ARTIFACTS_DIR</value>
   </data>
+  <data name="ToolSettingsNotFound" xml:space="preserve">
+    <value>Tool settings file does not exist for the tool {0}.</value>
+  </data>
 </root>

src/Cli/dotnet/ToolManifest/IToolManifestEditor.cs

@@ -10,7 +10,7 @@ namespace Microsoft.DotNet.ToolManifest
 {
     internal interface IToolManifestEditor
     {
-        void Add(FilePath manifest, PackageId packageId, NuGetVersion nuGetVersion, ToolCommandName[] toolCommandNames);
+        void Add(FilePath manifest, PackageId packageId, NuGetVersion nuGetVersion, ToolCommandName[] toolCommandNames, bool RollForward = false);
         void Remove(FilePath manifest, PackageId packageId);
         void Edit(FilePath manifest, PackageId packageId, NuGetVersion newNuGetVersion, ToolCommandName[] newToolCommandNames);
     }

src/Cli/dotnet/ToolManifest/LocalizableStrings.resx

@@ -169,4 +169,7 @@ For a list of locations searched, specify the "-d" option before the tool name.<
   <data name="MultipleSamePackageId" xml:space="preserve">
     <value>More than one entry exists for package(s): {0}.</value>
   </data>
+  <data name="ToolMissingRollForward" xml:space="preserve">
+    <value>Missing 'rollForward' entry.</value>
+  </data>
 </root>

src/Cli/dotnet/ToolManifest/ToolManifestEditor.cs

@@ -21,6 +21,7 @@ internal class ToolManifestEditor : IToolManifestEditor
         private const string JsonPropertyIsRoot = "isRoot";
         private const string JsonPropertyCommands = "commands";
         private const string JsonPropertyTools = "tools";
+        private const string JsonPropertyRollForward = "rollForward";
 
         public ToolManifestEditor(IFileSystem fileSystem = null, IDangerousFileDetector dangerousFileDetector = null)
         {
@@ -32,7 +33,8 @@ public void Add(
             FilePath manifest,
             PackageId packageId,
             NuGetVersion nuGetVersion,
-            ToolCommandName[] toolCommandNames)
+            ToolCommandName[] toolCommandNames,
+            bool rollForward = false)
         {
             SerializableLocalToolsManifest deserializedManifest =
                 DeserializeLocalToolsManifest(manifest);
@@ -45,10 +47,14 @@ public void Add(
             {
                 var existingPackage = existing.Single();
 
+                // Update the tool manifest if --roll-forward changes
                 if (existingPackage.PackageId.Equals(packageId)
                     && existingPackage.Version == nuGetVersion
                     && CommandNamesEqual(existingPackage.CommandNames, toolCommandNames))
                 {
+                    var toEdit = deserializedManifest.Tools.Single(t => new PackageId(t.PackageId).Equals(packageId));
+                    toEdit.RollForward = rollForward;
+                    _fileSystem.File.WriteAllText(manifest.Value, deserializedManifest.ToJson());
                     return;
                 }
 
@@ -70,7 +76,8 @@ public void Add(
                 {
                     PackageId = packageId.ToString(),
                     Version = nuGetVersion.ToNormalizedString(),
-                    Commands = toolCommandNames.Select(c => c.Value).ToArray()
+                    Commands = toolCommandNames.Select(c => c.Value).ToArray(),
+                    RollForward = rollForward,
                 });
 
             _fileSystem.File.WriteAllText(manifest.Value, deserializedManifest.ToJson());
@@ -199,6 +206,11 @@ private SerializableLocalToolsManifest DeserializeLocalToolsManifest(FilePath po
                                 serializableLocalToolSinglePackage.Commands = commands.ToArray();
                             }
 
+                            if (toolJson.Value.TryGetBooleanValue(JsonPropertyRollForward, out var rollForwardJson))
+                            {
+                                serializableLocalToolSinglePackage.RollForward = rollForwardJson;
+                            }
+
                             serializableLocalToolsManifest.Tools.Add(serializableLocalToolSinglePackage);
                         }
                     }
@@ -269,6 +281,8 @@ private List<ToolManifestPackage> GetToolManifestPackageFromOneManifestFile(
                     packageLevelErrors.Add(LocalizableStrings.FieldCommandsIsMissing);
                 }
 
+                bool rollForward = tools.RollForward;
+
                 if (packageLevelErrors.Any())
                 {
                     var joinedWithIndentation = string.Join(Environment.NewLine,
@@ -282,7 +296,8 @@ private List<ToolManifestPackage> GetToolManifestPackageFromOneManifestFile(
                         packageId,
                         version,
                         ToolCommandName.Convert(tools.Commands),
-                        correspondingDirectory));
+                        correspondingDirectory,
+                        rollForward));
                 }
             }
 
@@ -325,6 +340,7 @@ private class SerializableLocalToolSinglePackage
             public string PackageId { get; set; }
             public string Version { get; set; }
             public string[] Commands { get; set; }
+            public bool RollForward { get; set; }
         }
 
         private static bool CommandNamesEqual(ToolCommandName[] left, ToolCommandName[] right)
@@ -379,8 +395,8 @@ public string ToJson()
                         {
                             writer.WriteStringValue(toolCommandName);
                         }
-
                         writer.WriteEndArray();
+                        writer.WriteBoolean(JsonPropertyRollForward, tool.RollForward);
                         writer.WriteEndObject();
                     }
 

src/Cli/dotnet/ToolManifest/ToolManifestPackage.cs

@@ -13,6 +13,7 @@ internal struct ToolManifestPackage : IEquatable<ToolManifestPackage>
         public PackageId PackageId { get; }
         public NuGetVersion Version { get; }
         public ToolCommandName[] CommandNames { get; }
+        public bool RollForward { get; }
         /// <summary>
         /// The directory that will take effect first.
         /// When it is under .config directory, it is not .config directory
@@ -23,12 +24,14 @@ internal struct ToolManifestPackage : IEquatable<ToolManifestPackage>
         public ToolManifestPackage(PackageId packagePackageId,
             NuGetVersion version,
             ToolCommandName[] toolCommandNames,
-            DirectoryPath firstEffectDirectory)
+            DirectoryPath firstEffectDirectory,
+            bool rollForward)
         {
             FirstEffectDirectory = firstEffectDirectory;
             PackageId = packagePackageId;
             Version = version ?? throw new ArgumentNullException(nameof(version));
             CommandNames = toolCommandNames ?? throw new ArgumentNullException(nameof(toolCommandNames));
+            RollForward = rollForward;
         }
 
         public override bool Equals(object obj)
@@ -43,7 +46,8 @@ public bool Equals(ToolManifestPackage other)
                    EqualityComparer<NuGetVersion>.Default.Equals(Version, other.Version) &&
                    CommandNamesEqual(other.CommandNames) &&
                    FirstEffectDirectory.Value.TrimEnd('/', '\\')
-                     .Equals(other.FirstEffectDirectory.Value.TrimEnd('/', '\\'), StringComparison.Ordinal);
+                     .Equals(other.FirstEffectDirectory.Value.TrimEnd('/', '\\'), StringComparison.Ordinal) &&
+                     RollForward.Equals(other.RollForward);
         }
 
         private bool CommandNamesEqual(ToolCommandName[] otherCommandNames)
@@ -63,7 +67,7 @@ private bool CommandNamesEqual(ToolCommandName[] otherCommandNames)
 
         public override int GetHashCode()
         {
-            return HashCode.Combine(PackageId, Version, CommandNames);
+            return HashCode.Combine(PackageId, Version, CommandNames, RollForward);
         }
 
         public static bool operator ==(ToolManifestPackage tool1,