dotnet · DustinCampbell · Sep 11, 2025 · Sep 12, 2025 · Sep 15, 2025 · Sep 15, 2025
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal interface IWatchProjectFileInfoLoader
+{
+    Task<LoadProjectFileInfosResult> LoadProjectFileInfosAsync(
+        string projectFilePath,
+        string languageName,
+        CancellationToken cancellationToken);
+
+    Task<string?> TryGetProjectOutputPathAsync(string projectFilePath, CancellationToken cancellationToken);
+}
+
+internal readonly record struct LoadProjectFileInfosResult(
+    ImmutableArray<WatchProjectFileInfo> ProjectFileInfos,
+    ImmutableArray<WatchDiagnosticLogItem> DiagnosticItems);
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal interface IWatchProjectFileInfoLoaderFactory
+{
+    IWatchProjectFileInfoLoader Create(ImmutableDictionary<string, string> properties);
+}
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal readonly struct WatchDiagnosticLogItem
+{
+    internal DiagnosticLogItem UnderlyingObject { get; }
+
+    internal WatchDiagnosticLogItem(DiagnosticLogItem underlyingObject)
+    {
+        UnderlyingObject = underlyingObject;
+    }
+
+    public WatchDiagnosticLogItem(WatchDiagnosticLogItemKind kind, string message, string projectFilePath)
+        : this(new DiagnosticLogItem((DiagnosticLogItemKind)kind, message, projectFilePath))
+    {
+    }
+
+    public WatchDiagnosticLogItemKind Kind => (WatchDiagnosticLogItemKind)UnderlyingObject.Kind;
+
+    public string Message => UnderlyingObject.Message;
+
+    public string ProjectFilePath => UnderlyingObject.ProjectFilePath;
+
+    public override string ToString() => Message;
+}
@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal enum WatchDiagnosticLogItemKind
+{
+    Error = DiagnosticLogItemKind.Error,
+    Warning = DiagnosticLogItemKind.Warning,
+}
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+/// <summary>
+/// Represents a source file that is part of a project file.
+/// </summary>
+internal readonly struct WatchDocumentFileInfo
+{
+    internal DocumentFileInfo UnderlyingObject { get; }
+
+    internal WatchDocumentFileInfo(DocumentFileInfo underlyingObject)
+    {
+        UnderlyingObject = underlyingObject;
+    }
+
+    public WatchDocumentFileInfo(string filePath, string logicalPath, bool isLinked, bool isGenerated, ImmutableArray<string> folders)
+        : this(new(filePath, logicalPath, isLinked, isGenerated, folders))
+    {
+    }
+
+    /// <summary>
+    /// The absolute path to the document file on disk.
+    /// </summary>
+    public string FilePath => UnderlyingObject.FilePath;
+
+    /// <summary>
+    /// A fictional path to the document, relative to the project.
+    /// The document may not actually exist at this location, and is used
+    /// to represent linked documents. This includes the file name.
+    /// </summary>
+    public string LogicalPath => UnderlyingObject.LogicalPath;
+
+    /// <summary>
+    /// True if the document has a logical path that differs from its 
+    /// absolute file path.
+    /// </summary>
+    public bool IsLinked => UnderlyingObject.IsLinked;
+
+    /// <summary>
+    /// True if the file was generated during build.
+    /// </summary>
+    public bool IsGenerated => UnderlyingObject.IsGenerated;
+
+    /// <summary>
+    /// Containing folders of the document relative to the containing project root path.
+    /// </summary>
+    public ImmutableArray<string> Folders => UnderlyingObject.Folders;
+}
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal readonly struct WatchFileGlobs
+{
+    internal FileGlobs UnderlyingObject { get; }
+
+    internal WatchFileGlobs(FileGlobs underlyingObject)
+    {
+        UnderlyingObject = underlyingObject;
+    }
+
+    public WatchFileGlobs(ImmutableArray<string> includes, ImmutableArray<string> excludes, ImmutableArray<string> removes)
+        : this(new(includes, excludes, removes))
+    {
+
+    }
+
+    public ImmutableArray<string> Includes => UnderlyingObject.Includes;
+    public ImmutableArray<string> Excludes => UnderlyingObject.Excludes;
+    public ImmutableArray<string> Removes => UnderlyingObject.Removes;
+}
@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal static class WatchMSBuildProjectLoader
+{
+    public static MSBuildProjectLoader Create(
+        Workspace workspace,
+        IWatchProjectFileInfoLoaderFactory loaderFactory)
+        => Create(workspace, properties: null, loaderFactory);
+
+    public static MSBuildProjectLoader Create(
+        Workspace workspace,
+        ImmutableDictionary<string, string>? properties,
+        IWatchProjectFileInfoLoaderFactory loaderFactory)
+        => new(workspace, properties, new WatchProjectFileInfoLoaderFactory(loaderFactory));
+
+    private sealed class WatchProjectFileInfoLoaderFactory(IWatchProjectFileInfoLoaderFactory loaderFactory) : IProjectFileInfoLoaderFactory
+    {
+        public ProjectFileInfoLoader Create(
+            ImmutableDictionary<string, string> properties,
+            ProjectFileExtensionRegistry projectFileExtensionRegistry,
+            ProjectLoadOperationRunner operationRunner,
+            DiagnosticReporter diagnosticReporter,
+            ILoggerFactory loggerFactory)
+            => new WatchProjectFileInfoLoader(diagnosticReporter, projectFileExtensionRegistry, operationRunner, loaderFactory.Create(properties));
+    }
+
+    private sealed class WatchProjectFileInfoLoader(
+        DiagnosticReporter diagnosticReporter,
+        ProjectFileExtensionRegistry projectFileExtensionRegistry,
+        ProjectLoadOperationRunner operationRunner,
+        IWatchProjectFileInfoLoader loader)
+        : ProjectFileInfoLoader(diagnosticReporter, projectFileExtensionRegistry, operationRunner)
+    {
+        private readonly IWatchProjectFileInfoLoader _loader = loader;
+
+        public override ValueTask DisposeAsync()
+            => (_loader as IAsyncDisposable)?.DisposeAsync() ?? default;
+
+        public override async Task<ImmutableArray<ProjectFileInfo>> LoadProjectFileInfosAsync(
+            string projectFilePath,
+            DiagnosticReportingOptions reportingOptions,
+            CancellationToken cancellationToken)
+        {
+            if (!TryGetLanguageNameFromProjectPath(projectFilePath, reportingOptions, out var languageName))
+            {
+                return [];
+            }
+
+            var result = await _loader
+                .LoadProjectFileInfosAsync(projectFilePath, languageName, cancellationToken)
+                .ConfigureAwait(false);
+
+            ReportDiagnostics(result.DiagnosticItems.SelectAsArray(static x => x.UnderlyingObject));
+
+            return result.ProjectFileInfos.SelectAsArray(static x => x.UnderlyingObject);
+        }
+
+        public override Task<string?> TryGetProjectOutputPathAsync(string projectFilePath, CancellationToken cancellationToken)
+            => _loader.TryGetProjectOutputPathAsync(projectFilePath, cancellationToken);
+    }
+}
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.MSBuild.ExternalAccess.Watch.Api;
+
+internal readonly record struct WatchPackageReference
+{
+    internal PackageReference UnderlyingObject { get; }
+
+    internal WatchPackageReference(PackageReference underlyingObject)
+    {
+        UnderlyingObject = underlyingObject;
+    }
+
+    public WatchPackageReference(string name, string versionRange)
+        : this(new(name, versionRange))
+    {
+    }
+
+    public string Name => UnderlyingObject.Name;
+    public string VersionRange => UnderlyingObject.VersionRange;
+}