Merge branch 'main' into merge/release/9.0.3xx-to-main

Author: nagilson

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "microsoft.dotnet.darc": {
-      "version": "1.1.0-beta.25257.6",
+      "version": "1.1.0-beta.25259.3",
       "commands": [
         "darc"
       ]

eng/Version.Details.xml

@@ -38,14 +38,9 @@ steps:
       targetRidArgs='/p:TargetRid=${{ parameters.platform.targetRID }}'
     fi
 
-    runtimeOsArgs=
-    if [ '${{ parameters.platform.runtimeOS }}' != '' ]; then
-      runtimeOsArgs='/p:RuntimeOS=${{ parameters.platform.runtimeOS }}'
-    fi
-
-    baseOsArgs=
-    if [ '${{ parameters.platform.baseOS }}' != '' ]; then
-      baseOsArgs='/p:BaseOS=${{ parameters.platform.baseOS }}'
+    baseRidArgs=
+    if [ '${{ parameters.platform.baseRID }}' != '' ]; then
+      baseRidArgs='/p:BaseRid=${{ parameters.platform.baseRID }}'
     fi
 
     portableBuildArgs=
@@ -59,8 +54,7 @@ steps:
       ${{ parameters.platform.buildArguments }} \
       $internalRuntimeDownloadArgs \
       $targetRidArgs \
-      $runtimeOsArgs \
-      $baseOsArgs \
+      $baseRidArgs \
       $portableBuildArgs \
       /p:DotNetBuildSourceOnly=true \
       /p:DotNetBuildRepo=true \
@@ -71,7 +65,7 @@ steps:
     is1ESPipeline: ${{ parameters.is1ESPipeline }}
     args:
       displayName: Publish BuildLogs
-      targetPath: artifacts/log/$[ coalesce(variables._BuildConfig, 'Release') ]/
+      targetPath: artifacts/log/${{ coalesce(variables._BuildConfig, 'Release') }}
       artifactName: BuildLogs_SourceBuild_${{ parameters.platform.name }}_Attempt$(System.JobAttempt)
       continueOnError: true
       condition: succeededOrFailed()

eng/Versions.props

@@ -5,6 +5,9 @@
 # CI mode - set to true on CI server for PR validation build or official build.
 ci=${ci:-false}
 
+# Build mode
+source_build=${source_build:-false}
+
 # Set to true to use the pipelines logger which will enable Azure logging output.
 # https://github.com/Microsoft/azure-pipelines-tasks/blob/master/docs/authoring/commands.md
 # This flag is meant as a temporary opt-opt for the feature while validate it across
@@ -58,7 +61,8 @@ use_installed_dotnet_cli=${use_installed_dotnet_cli:-true}
 dotnetInstallScriptVersion=${dotnetInstallScriptVersion:-'v1'}
 
 # True to use global NuGet cache instead of restoring packages to repository-local directory.
-if [[ "$ci" == true ]]; then
+# Keep in sync with NuGetPackageroot in Arcade SDK's RepositoryLayout.props.
+if [[ "$ci" == true || "$source_build" == true ]]; then
   use_global_nuget_cache=${use_global_nuget_cache:-false}
 else
   use_global_nuget_cache=${use_global_nuget_cache:-true}

eng/common/core-templates/steps/source-build.yml

@@ -14,8 +14,8 @@
     }
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25257.101",
-    "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25257.101",
+    "Microsoft.DotNet.Arcade.Sdk": "10.0.0-beta.25260.104",
+    "Microsoft.DotNet.Helix.Sdk": "10.0.0-beta.25260.104",
     "Microsoft.Build.NoTargets": "3.7.0",
     "Microsoft.Build.Traversal": "3.4.0"
   }

eng/common/tools.sh

@@ -30,7 +30,7 @@ public override int Execute()
 
         // Find directives (this can fail, so do this before creating the target directory).
         var sourceFile = VirtualProjectBuildingCommand.LoadSourceFile(file);
-        var directives = VirtualProjectBuildingCommand.FindDirectivesForConversion(sourceFile, force: _force);
+        var directives = VirtualProjectBuildingCommand.FindDirectives(sourceFile, reportAllErrors: !_force, errors: null);
 
         Directory.CreateDirectory(targetDirectory);
 
@@ -50,7 +50,7 @@ public override int Execute()
         string projectFile = Path.Join(targetDirectory, Path.GetFileNameWithoutExtension(file) + ".csproj");
         using var stream = File.Open(projectFile, FileMode.Create, FileAccess.Write);
         using var writer = new StreamWriter(stream, Encoding.UTF8);
-        VirtualProjectBuildingCommand.WriteProjectFile(writer, directives);
+        VirtualProjectBuildingCommand.WriteProjectFile(writer, directives, isVirtualProject: false);
 
         return 0;
     }

global.json

@@ -0,0 +1,107 @@
+// 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.Immutable;
+using System.CommandLine;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Microsoft.DotNet.Cli.Commands.Run.Api;
+
+/// <summary>
+/// Takes JSON from stdin lines, produces JSON on stdout lines, doesn't perform any changes.
+/// Can be used by IDEs to see the project file behind a file-based program.
+/// </summary>
+internal sealed class RunApiCommand(ParseResult parseResult) : CommandBase(parseResult)
+{
+    public override int Execute()
+    {
+        for (string? line; (line = Console.ReadLine()) != null;)
+        {
+            if (string.IsNullOrWhiteSpace(line))
+            {
+                continue;
+            }
+
+            try
+            {
+                RunApiInput input = JsonSerializer.Deserialize(line, RunFileApiJsonSerializerContext.Default.RunApiInput)!;
+                RunApiOutput output = input.Execute();
+                Respond(output);
+            }
+            catch (Exception ex)
+            {
+                Respond(new RunApiOutput.Error { Message = ex.Message, Details = ex.ToString() });
+            }
+        }
+
+        return 0;
+
+        static void Respond(RunApiOutput message)
+        {
+            string json = JsonSerializer.Serialize(message, RunFileApiJsonSerializerContext.Default.RunApiOutput);
+            Console.WriteLine(json);
+        }
+    }
+}
+
+[JsonDerivedType(typeof(GetProject), nameof(GetProject))]
+internal abstract class RunApiInput
+{
+    private RunApiInput() { }
+
+    public abstract RunApiOutput Execute();
+
+    public sealed class GetProject : RunApiInput
+    {
+        public string? ArtifactsPath { get; init; }
+        public required string EntryPointFileFullPath { get; init; }
+
+        public override RunApiOutput Execute()
+        {
+            var sourceFile = VirtualProjectBuildingCommand.LoadSourceFile(EntryPointFileFullPath);
+            var errors = ImmutableArray.CreateBuilder<SimpleDiagnostic>();
+            var directives = VirtualProjectBuildingCommand.FindDirectives(sourceFile, reportAllErrors: true, errors);
+            string artifactsPath = ArtifactsPath ?? VirtualProjectBuildingCommand.GetArtifactsPath(EntryPointFileFullPath);
+
+            var csprojWriter = new StringWriter();
+            VirtualProjectBuildingCommand.WriteProjectFile(csprojWriter, directives, isVirtualProject: true, targetFilePath: EntryPointFileFullPath, artifactsPath: artifactsPath);
+
+            return new RunApiOutput.Project
+            {
+                Content = csprojWriter.ToString(),
+                Diagnostics = errors.ToImmutableArray(),
+            };
+        }
+    }
+}
+
+[JsonDerivedType(typeof(Error), nameof(Error))]
+[JsonDerivedType(typeof(Project), nameof(Project))]
+internal abstract class RunApiOutput
+{
+    private RunApiOutput() { }
+
+    /// <summary>
+    /// When the API shape or behavior changes, this should be incremented so the callers (IDEs) can act accordingly
+    /// (e.g., show an error message when an incompatible SDK version is being used).
+    /// </summary>
+    [JsonPropertyOrder(-1)]
+    public int Version { get; } = 1;
+
+    public sealed class Error : RunApiOutput
+    {
+        public required string Message { get; init; }
+        public required string Details { get; init; }
+    }
+
+    public sealed class Project : RunApiOutput
+    {
+        public required string Content { get; init; }
+        public required ImmutableArray<SimpleDiagnostic> Diagnostics { get; init; }
+    }
+}
+
+[JsonSerializable(typeof(RunApiInput))]
+[JsonSerializable(typeof(RunApiOutput))]
+internal partial class RunFileApiJsonSerializerContext : JsonSerializerContext;

src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Run.Api;
+
+internal sealed class RunApiCommandParser
+{
+    public static Command GetCommand()
+    {
+        Command command = new("run-api")
+        {
+            Hidden = true,
+        };
+
+        command.SetAction((parseResult) => new RunApiCommand(parseResult).Execute());
+        return command;
+    }
+}