[automated] Merge branch 'release/10.0.1xx' => 'main' (#50438)

Author: SimonZhao888

documentation/general/dotnet-run-file.md

@@ -38,7 +38,10 @@ Additionally, the implicit project file has the following customizations:
 
   - `ArtifactsPath` is set to a [temp directory](#build-outputs).
 
-  - `RuntimeHostConfigurationOption`s are set for `EntryPointFilePath` and `EntryPointFileDirectoryPath` which can be accessed in the app via `AppContext`:
+  - `PublishDir` and `PackageOutputPath` are set to `./artifacts/` so the outputs of `dotnet publish` and `dotnet pack` are next to the file-based app.
+
+  - `RuntimeHostConfigurationOption`s are set for `EntryPointFilePath` and `EntryPointFileDirectoryPath` (except for `Publish` and `Pack` targets)
+    which can be accessed in the app via `AppContext`:
 
     ```cs
     string? filePath = AppContext.GetData("EntryPointFilePath") as string;
@@ -101,7 +104,7 @@ the compilation consists solely of the single file read from the standard input.
 
 Commands `dotnet restore file.cs` and `dotnet build file.cs` are needed for IDE support and hence work for file-based programs.
 
-Command `dotnet publish file.cs` is also supported for file-based programs.
+Commands `dotnet publish file.cs` and `dotnet pack file.cs` are also supported for file-based programs.
 Note that file-based apps have implicitly set `PublishAot=true`, so publishing uses Native AOT (and building reports AOT warnings).
 To opt out, use `#:property PublishAot=false` directive in your `.cs` file.
 
@@ -373,7 +376,7 @@ so `dotnet file.cs` instead of `dotnet run file.cs` should be used in shebangs:
 
 ### Other possible commands
 
-We can consider supporting other commands like `dotnet pack`, `dotnet watch`,
+We can consider supporting other commands like `dotnet watch`,
 however the primary scenario is `dotnet run` and we might never support additional commands.
 
 All commands supporting file-based programs should have a way to receive the target path similarly to `dotnet run`,

src/Cli/dotnet/Commands/Pack/PackCommand.cs

@@ -4,16 +4,15 @@
 using System.Collections.ObjectModel;
 using System.CommandLine;
 using System.CommandLine.Parsing;
-using System.Configuration;
 using Microsoft.DotNet.Cli.Commands.Build;
 using Microsoft.DotNet.Cli.Commands.Restore;
+using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.NuGetPackageDownloader;
 using Microsoft.DotNet.Cli.Utils;
 using NuGet.Commands;
 using NuGet.Common;
 using NuGet.Packaging;
-using NuGet.Packaging.Core;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
@@ -23,33 +22,54 @@ public class PackCommand(
     string? msbuildPath = null
     ) : RestoringCommand(msbuildArgs, noRestore, msbuildPath: msbuildPath)
 {
-    public static PackCommand FromArgs(string[] args, string? msbuildPath = null)
+    public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
     {
         var parseResult = Parser.Parse(["dotnet", "pack", ..args]);
         return FromParseResult(parseResult, msbuildPath);
     }
 
-    public static PackCommand FromParseResult(ParseResult parseResult, string? msbuildPath = null)
+    public static CommandBase FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
-        var msbuildArgs = parseResult.OptionValuesToBeForwarded(PackCommandParser.GetCommand()).Concat(parseResult.GetValue(PackCommandParser.SlnOrProjectArgument) ?? []);
-
-        ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
-            new ReleasePropertyProjectLocator.DependentCommandOptions(
-                    parseResult.GetValue(PackCommandParser.SlnOrProjectArgument),
-                    parseResult.HasOption(PackCommandParser.ConfigurationOption) ? parseResult.GetValue(PackCommandParser.ConfigurationOption) : null
-                )
-        );
-
-        bool noRestore = parseResult.HasOption(PackCommandParser.NoRestoreOption) || parseResult.HasOption(PackCommandParser.NoBuildOption);
-        var parsedMSBuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(
-            msbuildArgs,
-            CommonOptions.PropertiesOption,
-            CommonOptions.RestorePropertiesOption,
-            PackCommandParser.TargetOption,
-            PackCommandParser.VerbosityOption);
-        return new PackCommand(
-            parsedMSBuildArgs.CloneWithAdditionalProperties(projectLocator.GetCustomDefaultConfigurationValueIfSpecified()),
-            noRestore,
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument) ?? [];
+
+        LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
+
+        bool noBuild = parseResult.HasOption(PackCommandParser.NoBuildOption);
+
+        bool noRestore = noBuild || parseResult.HasOption(PackCommandParser.NoRestoreOption);
+
+        return CommandFactory.CreateVirtualOrPhysicalCommand(
+            PackCommandParser.GetCommand(),
+            PackCommandParser.SlnOrProjectOrFileArgument,
+            (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
+                entryPointFileFullPath: Path.GetFullPath(appFilePath),
+                msbuildArgs: msbuildArgs)
+            {
+                NoBuild = noBuild,
+                NoRestore = noRestore,
+                NoCache = true,
+            },
+            (msbuildArgs, msbuildPath) =>
+            {
+                ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
+                    new ReleasePropertyProjectLocator.DependentCommandOptions(
+                            nonBinLogArgs,
+                            parseResult.HasOption(PackCommandParser.ConfigurationOption) ? parseResult.GetValue(PackCommandParser.ConfigurationOption) : null
+                        )
+                );
+                return new PackCommand(
+                    msbuildArgs.CloneWithAdditionalProperties(projectLocator.GetCustomDefaultConfigurationValueIfSpecified()),
+                    noRestore,
+                    msbuildPath);
+            },
+            optionsToUseWhenParsingMSBuildFlags:
+            [
+                CommonOptions.PropertiesOption,
+                CommonOptions.RestorePropertiesOption,
+                PackCommandParser.TargetOption,
+                PackCommandParser.VerbosityOption,
+            ],
+            parseResult,
             msbuildPath);
     }
 
@@ -67,7 +87,7 @@ private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions? verbos
 
     public static int RunPackCommand(ParseResult parseResult)
     {
-        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectArgument)?.ToList() ?? new List<string>();
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count != 1)
         {
@@ -112,7 +132,7 @@ public static int Run(ParseResult parseResult)
         parseResult.HandleDebugSwitch();
         parseResult.ShowHelpOrErrorIfAppropriate();
 
-        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectArgument)?.ToList() ?? new List<string>();
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count > 0 && Path.GetExtension(args[0]).Equals(".nuspec", StringComparison.OrdinalIgnoreCase))
         {

src/Cli/dotnet/Commands/Pack/PackCommandParser.cs

@@ -1,26 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.ObjectModel;
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Build;
 using Microsoft.DotNet.Cli.Commands.Restore;
 using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.DotNet.Cli.NuGetPackageDownloader;
-using NuGet.Commands;
-using NuGet.Common;
 using NuGet.Versioning;
-using static Microsoft.DotNet.Cli.Commands.Run.CSharpDirective;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
 internal static class PackCommandParser
 {
     public static readonly string DocsLink = "https://aka.ms/dotnet-pack";
 
-    public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CliStrings.SolutionOrProjectArgumentName)
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
-        Description = CliStrings.SolutionOrProjectArgumentDescription,
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
@@ -97,7 +92,7 @@ private static Command ConstructCommand()
     {
         var command = new DocumentedCommand("pack", DocsLink, CliCommandStrings.PackAppFullName);
 
-        command.Arguments.Add(SlnOrProjectArgument);
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(OutputOption);
         command.Options.Add(CommonOptions.ArtifactsPathOption);
         command.Options.Add(NoBuildOption);

src/Cli/dotnet/Commands/Publish/PublishCommand.cs

@@ -37,8 +37,6 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
         CommonOptions.ValidateSelfContainedOptions(parseResult.HasOption(PublishCommandParser.SelfContainedOption),
             parseResult.HasOption(PublishCommandParser.NoSelfContainedOption));
 
-        var forwardedOptions = parseResult.OptionValuesToBeForwarded(PublishCommandParser.GetCommand());
-
         bool noBuild = parseResult.HasOption(PublishCommandParser.NoBuildOption);
 
         bool noRestore = noBuild || parseResult.HasOption(PublishCommandParser.NoRestoreOption);

src/Cli/dotnet/Commands/Run/VirtualProjectBuildingCommand.cs

@@ -753,7 +753,7 @@ ProjectRootElement CreateProjectRootElement(ProjectCollection projectCollection)
                 isVirtualProject: true,
                 targetFilePath: EntryPointFileFullPath,
                 artifactsPath: ArtifactsPath,
-                includeRuntimeConfigInformation: !MSBuildArgs.RequestedTargets?.Contains("Publish") ?? true);
+                includeRuntimeConfigInformation: MSBuildArgs.RequestedTargets?.ContainsAny("Publish", "Pack") != true);
             var projectFileText = projectFileWriter.ToString();
 
             using var reader = new StringReader(projectFileText);
@@ -858,6 +858,7 @@ public static void WriteProjectFile(
                     <IncludeProjectNameInArtifactsPaths>false</IncludeProjectNameInArtifactsPaths>
                     <ArtifactsPath>{EscapeValue(artifactsPath)}</ArtifactsPath>
                     <PublishDir>artifacts/$(MSBuildProjectName)</PublishDir>
+                    <PackageOutputPath>artifacts/$(MSBuildProjectName)</PackageOutputPath>
                     <FileBasedProgram>true</FileBasedProgram>
                   </PropertyGroup>
 

src/Cli/dotnet/Program.cs

@@ -230,7 +230,18 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime)
         }
         PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStart();
         performanceData.Add("Startup Time", startupTime.TotalMilliseconds);
-        TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, performanceData));
+
+        string globalJsonState = string.Empty;
+        if (TelemetryClient.Enabled)
+        {
+            // Get the global.json state to report in telemetry along with this command invocation.
+            // We don't care about the actual SDK resolution, just the global.json information,
+            // so just pass empty string as executable directory for resolution.
+            NativeWrapper.SdkResolutionResult result = NativeWrapper.NETCoreSdkResolverNativeWrapper.ResolveSdk(string.Empty, Environment.CurrentDirectory);
+            globalJsonState = result.GlobalJsonState;
+        }
+
+        TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, performanceData, globalJsonState));
         PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStop();
 
         int exitCode;

src/Cli/dotnet/Telemetry/TelemetryFilter.cs

@@ -26,24 +26,40 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
     {
         var result = new List<ApplicationInsightsEntryFormat>();
         Dictionary<string, double> measurements = null;
+        string globalJsonState = string.Empty;
         if (objectToFilter is Tuple<ParseResult, Dictionary<string, double>> parseResultWithMeasurements)
         {
             objectToFilter = parseResultWithMeasurements.Item1;
             measurements = parseResultWithMeasurements.Item2;
             measurements = RemoveZeroTimes(measurements);
         }
+        else if (objectToFilter is Tuple<ParseResult, Dictionary<string, double>, string> parseResultWithMeasurementsAndGlobalJsonState)
+        {
+            objectToFilter = parseResultWithMeasurementsAndGlobalJsonState.Item1;
+            measurements = parseResultWithMeasurementsAndGlobalJsonState.Item2;
+            measurements = RemoveZeroTimes(measurements);
+            globalJsonState = parseResultWithMeasurementsAndGlobalJsonState.Item3;
+        }
 
         if (objectToFilter is ParseResult parseResult)
         {
             var topLevelCommandName = parseResult.RootSubCommandResult();
             if (topLevelCommandName != null)
             {
+                Dictionary<string, string> properties = new()
+                {
+                    ["verb"] = topLevelCommandName
+                };
+                if (!string.IsNullOrEmpty(globalJsonState))
+                {
+                    properties["globalJson"] = globalJsonState;
+                }
+
                 result.Add(new ApplicationInsightsEntryFormat(
                     "toplevelparser/command",
-                    new Dictionary<string, string>()
-                    {{ "verb", topLevelCommandName }}
-                    , measurements
-                    ));
+                    properties,
+                    measurements
+                ));
 
                 LogVerbosityForAllTopLevelCommand(result, parseResult, topLevelCommandName, measurements);
 

src/Resolvers/Microsoft.DotNet.NativeWrapper/Interop.cs

@@ -80,6 +80,7 @@ internal enum hostfxr_resolve_sdk2_result_key_t : int
             resolved_sdk_dir = 0,
             global_json_path = 1,
             requested_version = 2,
+            global_json_state = 3,
         }
 
         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

src/Resolvers/Microsoft.DotNet.NativeWrapper/SdkResolutionResult.cs

@@ -20,6 +20,11 @@ public class SdkResolutionResult
         /// </summary>
         public string? RequestedVersion;
 
+        /// <summary>
+        /// Result of the global.json search
+        /// </summary>
+        public string? GlobalJsonState;
+
         /// <summary>
         /// True if a global.json was found but there was no compatible SDK, so it was ignored. 
         /// </summary>
@@ -38,6 +43,9 @@ internal void Initialize(Interop.hostfxr_resolve_sdk2_result_key_t key, string v
                 case Interop.hostfxr_resolve_sdk2_result_key_t.requested_version:
                     RequestedVersion = value;
                     break;
+                case Interop.hostfxr_resolve_sdk2_result_key_t.global_json_state:
+                    GlobalJsonState = value;
+                    break;
             }
         }
     }

test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetPackInvocation.cs

@@ -41,7 +41,7 @@ public void MsbuildInvocationIsCorrect(string[] args, string[] expectedAdditiona
                     .ToArray();
 
                 var msbuildPath = "<msbuildpath>";
-                var command = PackCommand.FromArgs(args, msbuildPath);
+                var command = (PackCommand)PackCommand.FromArgs(args, msbuildPath);
                 var expectedPrefix = args.FirstOrDefault() == "--no-build" ? ExpectedNoBuildPrefix : [.. ExpectedPrefix, .. GivenDotnetBuildInvocation.RestoreExpectedPrefixForImplicitRestore];
 
                 command.SeparateRestoreCommand.Should().BeNull();