Merge pull request #22188 from unoplatform/dev/dr/miscHr

fix(hr): HR builds all targets

Author: dr1rrb

src/Uno.UI.RemoteControl.Host/RemoteControlExtensions.cs

@@ -104,8 +104,7 @@ private static async Task HandleWebSocketConnectionRequest(WebApplication app, H
 						throw new InvalidOperationException("IIdeChannel is required"),
 						context.RequestServices);
 
-					await server.RunAsync(await context.WebSockets.AcceptWebSocketAsync(),
-						CancellationToken.None);
+					await server.RunAsync(await context.WebSockets.AcceptWebSocketAsync(), context.RequestAborted);
 				}
 				else
 				{

src/Uno.UI.RemoteControl.Server.Processors/HotReload/MetadataUpdates/CompilationWorkspaceProvider.cs

@@ -21,14 +21,14 @@ internal static class CompilationWorkspaceProvider
 	{
 		private static string MSBuildBasePath = "";
 
-		public static async Task<(Solution, WatchHotReloadService)> CreateWorkspaceAsync(
+		public static async Task<(Workspace, WatchHotReloadService)> CreateWorkspaceAsync(
 			string projectPath,
 			IReporter reporter,
 			string[] metadataUpdateCapabilities,
 			Dictionary<string, string> properties,
 			CancellationToken ct)
 		{
-			if (properties.TryGetValue("UnoHotReloadDiagnosticsLogPath", out var logPath))
+			if (properties.TryGetValue("UnoHotReloadDiagnosticsLogPath", out var logPath) && logPath is { Length: > 0 })
 			{
 				// Sets Roslyn's environment variable for troubleshooting HR, see:
 				// https://github.com/dotnet/roslyn/blob/fc6e0c25277ff440ca7ded842ac60278ee6c9695/src/Features/Core/Portable/EditAndContinue/EditAndContinueService.cs#L72
@@ -102,7 +102,7 @@ static bool IsValidProperty(string property)
 				await project.GetCompilationAsync(ct);
 			}
 
-			return (currentSolution, hotReloadService);
+			return (workspace, hotReloadService);
 		}
 
 		public static void InitializeRoslyn(string? workDir)

src/Uno.UI.RemoteControl.Server.Processors/HotReload/ServerHotReloadProcessor.MetadataUpdate.cs

@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
 using Uno.Disposables;
+using Uno.Extensions;
 using Uno.Threading;
 using Uno.UI.RemoteControl.Helpers;
 using Uno.UI.RemoteControl.Host.HotReload.MetadataUpdates;
@@ -33,14 +34,11 @@ partial class ServerHotReloadProcessor : IServerProcessor, IDisposable
 		private static readonly StringComparer _pathsComparer = OperatingSystem.IsWindows() ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
 		private static readonly StringComparison _pathsComparison = OperatingSystem.IsWindows() ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
 
-		private IDisposable? _solutionSubscriptions;
 		private readonly FastAsyncLock _solutionUpdateGate = new();
 		private readonly BufferGate _solutionWatchersGate = new();
 
-		private Task<(Solution, WatchHotReloadService)>? _initializeTask;
-		private Solution? _currentSolution;
-		private WatchHotReloadService? _hotReloadService;
-		private IReporter _reporter = new Reporter();
+		private (Task<HotReloadWorkspace> GetAsync, CancellationTokenSource Ct)? _workspace;
+		private readonly IReporter _reporter = new Reporter();
 
 		private bool _useRoslynHotReload;
 		private bool _useHotReloadThruDebugger;
@@ -77,6 +75,12 @@ private void InitializeInner(ConfigureServer configureServer)
 		{
 			try
 			{
+				if (_workspace is not null)
+				{
+					_reporter.Warn("Hot-reload workspace is already initialized.");
+					return;
+				}
+
 				if (Assembly.Load("Microsoft.CodeAnalysis.Workspaces") is { } wsAsm)
 				{
 					// If this assembly was loaded from a stream, it will not have a location.
@@ -90,7 +94,8 @@ private void InitializeInner(ConfigureServer configureServer)
 
 				CompilationWorkspaceProvider.InitializeRoslyn(Path.GetDirectoryName(configureServer.ProjectPath));
 
-				_initializeTask = InitializeAsync(CancellationToken.None);
+				var ct = new CancellationTokenSource();
+				_workspace = (InitializeAsync(ct.Token), ct);
 			}
 			catch (Exception e)
 			{
@@ -101,20 +106,22 @@ private void InitializeInner(ConfigureServer configureServer)
 
 				throw;
 			}
-			async Task<(Solution, WatchHotReloadService)> InitializeAsync(CancellationToken ct)
+			async Task<HotReloadWorkspace> InitializeAsync(CancellationToken ct)
 			{
 				try
 				{
 					await Notify(HotReloadEvent.Initializing);
 
-					var (outputPath, intermediateOutputPath, solution, watch) = await CreateCompilation(configureServer, ct);
+					var workspace = await CreateCompilation(configureServer, ct);
+					ct.Register(() => workspace.Dispose());
 
-					ObserveSolutionPaths(solution, intermediateOutputPath, outputPath);
+					var fileSystemWatch = ObserveSolutionPaths(workspace.CurrentSolution, workspace.OutputPaths);
+					ct.Register(() => fileSystemWatch.Dispose());
 
 					await _remoteControlServer.SendFrame(new HotReloadWorkspaceLoadResult { WorkspaceInitialized = true });
 					await Notify(HotReloadEvent.Ready);
 
-					return (solution, watch);
+					return workspace;
 				}
 				catch (Exception e)
 				{
@@ -128,7 +135,19 @@ private void InitializeInner(ConfigureServer configureServer)
 			}
 		}
 
-		private async Task<(string? outputPath, string? intermediateOutputPath, Solution solution, WatchHotReloadService watch)> CreateCompilation(ConfigureServer configureServer, CancellationToken ct)
+		private record HotReloadWorkspace(Workspace InnerWorkspace, WatchHotReloadService WatchService, string?[] OutputPaths) : IDisposable
+		{
+			public Solution CurrentSolution { get; set; } = InnerWorkspace.CurrentSolution;
+
+			/// <inheritdoc />
+			public void Dispose()
+			{
+				WatchService.EndSession();
+				InnerWorkspace.Dispose();
+			}
+		}
+
+		private async Task<HotReloadWorkspace> CreateCompilation(ConfigureServer configureServer, CancellationToken ct)
 		{
 			// Clone the properties from the ConfigureServer
 			var properties = configureServer.MSBuildProperties.ToDictionary();
@@ -166,19 +185,50 @@ private void InitializeInner(ConfigureServer configureServer)
 			if (properties.Remove("TargetFramework", out var targetFramework))
 			{
 				properties["UnoHotReloadTargetFramework"] = targetFramework;
+				properties["TargetFrameworks"] = targetFramework;
 			}
 
-			var (solution, watch) = await CompilationWorkspaceProvider.CreateWorkspaceAsync(
+			var (workspace, watch) = await CompilationWorkspaceProvider.CreateWorkspaceAsync(
 				configureServer.ProjectPath,
 				_reporter,
 				configureServer.MetadataUpdateCapabilities,
 				properties,
 				ct);
-			return (outputPath, intermediateOutputPath, solution, watch);
+
+			return new HotReloadWorkspace(workspace, watch, [Trim(outputPath), Trim(intermediateOutputPath)]);
+
+			// We make sure to trim the output path from any TFM / RID / Configuration suffixes
+			// This is to make sure that if we have multiple active HR workspace (like an old Android emulator reconnecting while a desktop app is running),
+			// we will not consider the files of the other targets.
+			string? Trim(string? outDir)
+			{
+				var result = outDir;
+				while (!string.IsNullOrWhiteSpace(result))
+				{
+					var updated = result
+						.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+						.TrimEnd(targetFramework, _pathsComparison)
+						.TrimEnd(runtimeIdentifier, _pathsComparison)
+						.TrimEnd(properties.GetValueOrDefault("Configuration"), _pathsComparison);
+					if (updated == result)
+					{
+						return result + Path.DirectorySeparatorChar; // We make sure to restore the dir separator at the end to make sure filters applies only on folders!
+					}
+					else
+					{
+						result = updated;
+					}
+				}
+
+				return null;
+			}
 		}
 
-		private void ObserveSolutionPaths(Solution solution, params string?[] excludedDirPattern)
+		private IDisposable ObserveSolutionPaths(Solution solution, params string?[] excludedDirPattern)
 		{
+			// TODO: Resolve the bin and obj folders from the project (instead of assuming same config for all projects)
+			// e.g.: projectDir.First().AnalyzerOptions.AnalyzerConfigOptionsProvider.GlobalOptions.TryGetValue("build_property.intermediateoutputpath", out string value)
+			// Not implemented yet: for a netstd2.0 project, we don't have properties such intermediateoutputpath available!
 			ImmutableArray<string> excludedDir =
 			[
 				.. from pattern in excludedDirPattern
@@ -215,7 +265,7 @@ select Path.Combine(projectDir, pattern).TrimEnd(Path.DirectorySeparatorChar, Pa
 				filePaths => _ = ProcessFileChanges(filePaths, processing.Token),
 				e => Console.WriteLine($"Error {e}"));
 
-			_solutionSubscriptions = new CompositeDisposable([watchersSubscription, Disposable.Create(processing.Cancel), processing, .. watchers]);
+			return new CompositeDisposable([watchersSubscription, Disposable.Create(processing.Cancel), processing, .. watchers]);
 
 			bool HasInterest(string path)
 			{
@@ -276,7 +326,7 @@ private async Task ProcessFileChanges(Task<ImmutableHashSet<string>> filesAsync,
 
 		private async ValueTask ProcessSolutionChanged(HotReloadServerOperation hotReload, ImmutableHashSet<string> files, CancellationToken ct)
 		{
-			if (!await EnsureSolutionInitializedAsync() || _currentSolution is null || _hotReloadService is null)
+			if (await GetWorkspaceAsync() is not { } workspace)
 			{
 				await hotReload.Complete(HotReloadServerResult.Failed); // Failed to init the workspace
 				return;
@@ -285,11 +335,11 @@ private async ValueTask ProcessSolutionChanged(HotReloadServerOperation hotReloa
 			var sw = Stopwatch.StartNew();
 
 			// Detects the changes and try to update the solution
-			var originalSolution = _currentSolution;
+			var originalSolution = workspace.CurrentSolution;
 			var changeSet = await DiscoverChangesAsync(originalSolution, files, ct);
 			var solution = await Apply(originalSolution, changeSet, hotReload, ct);
 
-			if (solution == _currentSolution)
+			if (solution == originalSolution)
 			{
 				_reporter.Output($"No changes found in {string.Join(",", files.Select(Path.GetFileName))}");
 
@@ -299,10 +349,10 @@ private async ValueTask ProcessSolutionChanged(HotReloadServerOperation hotReloa
 
 			// No matter if the build will succeed or not, we update the _currentSolution.
 			// Files needs to be updated again to fix the compilation errors.
-			_currentSolution = solution;
+			workspace.CurrentSolution = solution;
 
 			// Compile the solution and get deltas
-			var (updates, hotReloadDiagnostics) = await _hotReloadService.EmitSolutionUpdateAsync(solution, ct);
+			var (updates, hotReloadDiagnostics) = await workspace.WatchService.EmitSolutionUpdateAsync(solution, ct);
 			// hotReloadDiagnostics currently includes semantic Warnings and Errors for types being updated. We want to limit rude edits to the class
 			// of unrecoverable errors that a user cannot fix and requires an app rebuild.
 			var rudeEdits = hotReloadDiagnostics.RemoveAll(d => d.Severity == DiagnosticSeverity.Warning || !d.Descriptor.Id.StartsWith("ENC", StringComparison.Ordinal));
@@ -457,28 +507,21 @@ private ImmutableArray<string> GetCompilationErrors(Solution solution, Cancellat
 			return builder;
 		}
 
-		[MemberNotNullWhen(true, nameof(_currentSolution), nameof(_hotReloadService))]
-		private async ValueTask<bool> EnsureSolutionInitializedAsync()
+		private async ValueTask<HotReloadWorkspace?> GetWorkspaceAsync()
 		{
-			if (_currentSolution is not null && _hotReloadService is not null)
+			if (_workspace is null)
 			{
-				return true;
-			}
-
-			if (_initializeTask is null)
-			{
-				return false;
+				return null;
 			}
 
 			try
 			{
-				(_currentSolution, _hotReloadService) = await _initializeTask;
-				return true;
+				return await _workspace.Value.GetAsync;
 			}
 			catch (Exception ex)
 			{
 				_reporter.Warn(ex.Message);
-				return false;
+				return null;
 			}
 		}
 
@@ -560,7 +603,7 @@ private async ValueTask<ChangeSet> DiscoverChangesAsync(Solution solution, Immut
 			ImmutableHashSet<string> newFiles,
 			CancellationToken ct)
 		{
-			if (_configureServer is null || _currentSolution is null)
+			if (_configureServer is null)
 			{
 				_reporter.Warn("Cannot handle new files: configuration not available.");
 				return ([], [], newFiles);
@@ -571,12 +614,13 @@ private async ValueTask<ChangeSet> DiscoverChangesAsync(Solution solution, Immut
 				return ([], [], newFiles);
 			}
 
+			HotReloadWorkspace? tempWorkspace = null;
 			try
 			{
 				_reporter.Output($"Detected {newFiles.Count} potentially new file(s). Creating temporary workspace to discover them...");
 
 				// Create a temporary workspace to discover the new files
-				var (_, _, tempSolution, _) = await CreateCompilation(_configureServer, ct);
+				tempWorkspace = await CreateCompilation(_configureServer, ct);
 
 				var discoveredDocuments = ImmutableArray.CreateBuilder<AddedDocumentInfo>();
 				var discoveredAdditionalDocuments = ImmutableArray.CreateBuilder<AddedDocumentInfo>();
@@ -587,7 +631,7 @@ private async ValueTask<ChangeSet> DiscoverChangesAsync(Solution solution, Immut
 					// Search for the file in the temp workspace's projects
 					// Note: Here again we assume that document can appear in more than one project (same project loaded with different TFM)
 					var found = false;
-					foreach (var project in tempSolution.Projects)
+					foreach (var project in tempWorkspace.CurrentSolution.Projects)
 					{
 						if (project.Documents.FirstOrDefault(d => string.Equals(d.FilePath, file, _pathsComparison)) is { } document)
 						{
@@ -614,6 +658,10 @@ private async ValueTask<ChangeSet> DiscoverChangesAsync(Solution solution, Immut
 				_reporter.Warn($"Error while discovering new files: {ex.Message}");
 				return ([], [], newFiles);
 			}
+			finally
+			{
+				tempWorkspace?.Dispose();
+			}
 		}
 
 		private static async ValueTask<Solution> Apply(Solution solution, ChangeSet changeSet, HotReloadServerOperation hotReload, CancellationToken ct)

src/Uno.UI.RemoteControl.Server.Processors/HotReload/ServerHotReloadProcessor.cs

@@ -854,10 +854,7 @@ private async Task<bool> RequestHotReloadToIde()
 		#endregion
 
 		public void Dispose()
-		{
-			_solutionSubscriptions?.Dispose();
-			_hotReloadService?.EndSession();
-		}
+			=> _workspace?.Ct.Cancel();
 
 		#region Helpers
 		private class BufferGate

src/Uno.UI.RemoteControl/HotReload/ClientHotReloadProcessor.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using Uno.Foundation.Logging;
@@ -93,7 +94,7 @@ private async Task ConfigureServer()
 					_status.ReportInvalidRuntime();
 				}
 
-				var hrDebug = Environment.GetEnvironmentVariable("__UNO_SUPPORT_DEBUG_HOT_RELOAD__") == "true";
+				var hrDebug = Debugger.IsAttached && Environment.GetEnvironmentVariable("__UNO_SUPPORT_DEBUG_HOT_RELOAD__") == "true";
 				var message = new ConfigureServer(
 					_projectPath,
 					GetMetadataUpdateCapabilities(),