Merge pull request #9724 from drewnoakes/remove-obsolete-code

Remove obsolete code

Author: drewnoakes

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/ActiveConfiguredProjectsProvider.cs

@@ -8,8 +8,8 @@ namespace Microsoft.VisualStudio.ProjectSystem;
 [Export(typeof(IActiveConfiguredProjectsProvider))]
 internal class ActiveConfiguredProjectsProvider : IActiveConfiguredProjectsProvider
 {
-    // A project configuration is considered active if its dimensions matches the active solution configuration skipping 
-    // any ignored dimensions names (provided by IActiveConfiguredProjectsDimensionProvider instances):
+    // A project configuration is considered active if its dimensions match the active solution configuration, skipping 
+    // any ignored dimensions names (provided by IActiveConfiguredProjectsDimensionProvider instances).
     //
     // For example, given the following cross-targeting project:
     //
@@ -63,35 +63,6 @@ public ActiveConfiguredProjectsProvider(IUnconfiguredProjectServices services, U
     [ImportMany]
     public OrderPrecedenceImportCollection<IActiveConfiguredProjectsDimensionProvider> DimensionProviders { get; }
 
-    public async Task<ImmutableDictionary<string, ConfiguredProject>?> GetActiveConfiguredProjectsMapAsync()
-    {
-        ActiveConfiguredObjects<ConfiguredProject>? projects = await GetActiveConfiguredProjectsAsync();
-
-        if (projects?.Objects.IsEmpty != false)
-        {
-            return null;
-        }
-
-        var builder = PooledDictionary<string, ConfiguredProject>.GetInstance();
-
-        bool isCrossTargeting = projects.Objects.All(project => project.ProjectConfiguration.IsCrossTargeting());
-
-        if (isCrossTargeting)
-        {
-            foreach (ConfiguredProject project in projects.Objects)
-            {
-                string targetFramework = project.ProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty];
-                builder.Add(targetFramework, project);
-            }
-        }
-        else
-        {
-            builder.Add(string.Empty, projects.Objects[0]);
-        }
-
-        return builder.ToImmutableDictionaryAndFree();
-    }
-
     public async Task<ActiveConfiguredObjects<ConfiguredProject>?> GetActiveConfiguredProjectsAsync()
     {
         ActiveConfiguredObjects<ProjectConfiguration>? configurations = await GetActiveProjectConfigurationsAsync();

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/ActiveDebugFrameworkServices.cs

@@ -21,9 +21,6 @@ public ActiveDebugFrameworkServices(IActiveConfiguredProjectsProvider activeConf
         _commonProjectServices = commonProjectServices;
     }
 
-    /// <summary>
-    /// <see cref="IActiveDebugFrameworkServices.GetProjectFrameworksAsync"/>
-    /// </summary>
     public async Task<List<string>?> GetProjectFrameworksAsync()
     {
         // It is important that we return the frameworks in the order they are specified in the project to ensure the default is set
@@ -40,68 +37,83 @@ public ActiveDebugFrameworkServices(IActiveConfiguredProjectsProvider activeConf
         return BuildUtilities.GetPropertyValues(targetFrameworks).ToList();
     }
 
-    /// <summary>
-    /// <see cref="IActiveDebugFrameworkServices.SetActiveDebuggingFrameworkPropertyAsync"/>
-    /// </summary>
     public async Task SetActiveDebuggingFrameworkPropertyAsync(string activeFramework)
     {
         ProjectDebugger props = await _commonProjectServices.ActiveConfiguredProjectProperties.GetProjectDebuggerPropertiesAsync();
+
         await props.ActiveDebugFramework.SetValueAsync(activeFramework);
     }
 
-    /// <summary>
-    /// <see cref="IActiveDebugFrameworkServices.GetActiveDebuggingFrameworkPropertyAsync"/>
-    /// </summary>
     public async Task<string?> GetActiveDebuggingFrameworkPropertyAsync()
     {
         ProjectDebugger props = await _commonProjectServices.ActiveConfiguredProjectProperties.GetProjectDebuggerPropertiesAsync();
-        string? activeValue = await props.ActiveDebugFramework.GetValueAsync() as string;
-        return activeValue;
+
+        return await props.ActiveDebugFramework.GetValueAsync() as string;
     }
 
-    /// <summary>
-    /// <see cref="IActiveDebugFrameworkServices.GetConfiguredProjectForActiveFrameworkAsync"/>
-    /// </summary>
     public async Task<ConfiguredProject?> GetConfiguredProjectForActiveFrameworkAsync()
     {
-#pragma warning disable CS0618 // Type or member is obsolete
-        ImmutableDictionary<string, ConfiguredProject>? configProjects = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsMapAsync();
-#pragma warning restore CS0618 // Type or member is obsolete
+        ActiveConfiguredObjects<ConfiguredProject>? projects = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsAsync();
 
-        if (configProjects is null)
+        if (projects is null || projects.Objects.IsEmpty)
         {
             return null;
         }
 
-        // If there is only one we are done
-        if (configProjects.Count == 1)
+        if (projects.Objects.Length is 1)
         {
-            return configProjects.First().Value;
+            return projects.Objects[0];
         }
 
-        string? activeFramework = await GetActiveDebuggingFrameworkPropertyAsync();
+        bool isMultiTargeting = projects.Objects.All(project => project.ProjectConfiguration.IsCrossTargeting());
 
-        if (!Strings.IsNullOrWhiteSpace(activeFramework))
+        if (isMultiTargeting)
         {
-            if (configProjects.TryGetValue(activeFramework, out ConfiguredProject? configuredProject))
+            string? activeDebugFramework = await GetActiveDebuggingFrameworkPropertyAsync();
+
+            ConfiguredProject? project = FindProject(activeDebugFramework);
+
+            if (project is null)
             {
-                return configuredProject;
+                // The expected debug framework was not found, so we need to pick one.
+                // Use the first target as defined in the TargetFrameworks property. This is treated specially.
+                // We must pick the first that was defined can't just select the first one. If activeFramework is not set we must pick the first one as defined by the 
+                // targetFrameworks property. So we need the order as returned by GetProjectFrameworks()
+                if (await GetProjectFrameworksAsync() is [string firstFramework, ..])
+                {
+                    project = FindProject(firstFramework);
+                }
             }
+
+            System.Diagnostics.Debug.Assert(project is not null, "Unable to determine debug project configuration.");
+
+            return project;
         }
+        else
+        {
+            System.Diagnostics.Debug.Assert(projects.Objects.Length == 1, "Expected only one active configured project when not cross-targeting.");
 
-        // We can't just select the first one. If activeFramework is not set we must pick the first one as defined by the 
-        // targetFrameworks property. So we need the order as returned by GetProjectFrameworks()
-        List<string>? frameworks = await GetProjectFrameworksAsync();
+            return projects.Objects[0];
+        }
 
-        if (frameworks?.Count > 0)
+        ConfiguredProject? FindProject(string? targetFramework)
         {
-            if (configProjects.TryGetValue(frameworks[0], out ConfiguredProject? configuredProject))
+            if (Strings.IsNullOrWhiteSpace(targetFramework))
             {
-                return configuredProject;
+                return null;
             }
-        }
 
-        // All that is left is to return the first one.
-        return configProjects.First().Value;
+            foreach (ConfiguredProject project in projects.Objects)
+            {
+                string tf = project.ProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty];
+
+                if (StringComparers.ConfigurationDimensionValues.Equals(tf, targetFramework))
+                {
+                    return project;
+                }
+            }
+
+            return null;
+        }
     }
 }

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/IActiveDebugFrameworkServices.cs

@@ -25,7 +25,7 @@ public interface IActiveDebugFrameworkServices
     Task<string?> GetActiveDebuggingFrameworkPropertyAsync();
 
     /// <summary>
-    /// Returns the configured project which represents the active framework. This is valid whether multi-targeting or not.
+    /// Returns the configured project that corresponds with the active debugging framework. This is valid whether multi-targeting or not.
     /// </summary>
     Task<ConfiguredProject?> GetConfiguredProjectForActiveFrameworkAsync();
 }

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/IActiveConfiguredProjectsProvider.cs

@@ -14,18 +14,6 @@ namespace Microsoft.VisualStudio.ProjectSystem;
 [ProjectSystemContract(ProjectSystemContractScope.UnconfiguredProject, ProjectSystemContractProvider.Private, Cardinality = ImportCardinality.ExactlyOne)]
 internal interface IActiveConfiguredProjectsProvider
 {
-    /// <summary>
-    ///     Gets all the active configured projects by TargetFramework dimension for the current unconfigured project.
-    ///     If the current project is not a cross-targeting project, then it returns a singleton key-value pair with an
-    ///     ignorable key and single active configured project as value.
-    /// </summary>
-    /// <returns>
-    ///     Map from TargetFramework dimension to active configured project, or <see langword="null" /> if there
-    ///     are no active <see cref="ConfiguredProject"/> objects.
-    /// </returns>
-    [Obsolete("This method will be removed in a future build.")]
-    Task<ImmutableDictionary<string, ConfiguredProject>?> GetActiveConfiguredProjectsMapAsync();
-
     /// <summary>
     ///     Returns the ordered list of configured projects that are active for the current project, loading them if needed.
     /// </summary>

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/Mocks/IActiveConfiguredProjectsProviderFactory.cs

@@ -2,14 +2,9 @@
 
 namespace Microsoft.VisualStudio.ProjectSystem.Debug;
 
-internal class IActiveConfiguredProjectsProviderFactory
+internal class IActiveConfiguredProjectsProviderFactory(MockBehavior mockBehavior = MockBehavior.Strict)
 {
-    private readonly Mock<IActiveConfiguredProjectsProvider> _mock;
-
-    public IActiveConfiguredProjectsProviderFactory(MockBehavior mockBehavior = MockBehavior.Strict)
-    {
-        _mock = new Mock<IActiveConfiguredProjectsProvider>(mockBehavior);
-    }
+    private readonly Mock<IActiveConfiguredProjectsProvider> _mock = new(mockBehavior);
 
     public IActiveConfiguredProjectsProvider Object => _mock.Object;
 
@@ -18,15 +13,6 @@ public void Verify()
         _mock.Verify();
     }
 
-    public IActiveConfiguredProjectsProviderFactory ImplementGetActiveConfiguredProjectsMapAsync(ImmutableDictionary<string, ConfiguredProject> configuredProjects)
-    {
-#pragma warning disable CS0618 // Type or member is obsolete
-        _mock.Setup(x => x.GetActiveConfiguredProjectsMapAsync())
-#pragma warning restore CS0618 // Type or member is obsolete
-                          .ReturnsAsync(configuredProjects);
-        return this;
-    }
-
     public IActiveConfiguredProjectsProviderFactory ImplementGetActiveConfiguredProjectsAsync(ActiveConfiguredObjects<ConfiguredProject> configuredProjects)
     {
         _mock.Setup(x => x.GetActiveConfiguredProjectsAsync())

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/ProjectSystem/Debug/ActiveDebugFrameworkServicesTests.cs

@@ -74,23 +74,25 @@ public async Task GetConfiguredProjectForActiveFrameworkAsync_ReturnsCorrectProj
         var data = new PropertyPageData(ProjectDebugger.SchemaName, ProjectDebugger.ActiveDebugFrameworkProperty, framework);
         var data2 = new PropertyPageData(ConfigurationGeneral.SchemaName, ConfigurationGeneral.TargetFrameworksProperty, "net462;net461;netcoreapp1.0");
 
-        var projects = ImmutableStringDictionary<ConfiguredProject>.EmptyOrdinal
-                        .Add("net461", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net461", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "net461"))))
-                        .Add("netcoreapp1.0", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|netcoreapp1.0", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "netcoreapp1.0"))))
-                        .Add("net462", ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net462", Empty.PropertiesMap
-                                                                                .Add("Configuration", "Debug")
-                                                                                .Add("Platform", "AnyCPU")
-                                                                                .Add("TargetFramework", "net462"))));
+        ImmutableArray<ConfiguredProject> projects =
+        [
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net461", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "net461"))),
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|netcoreapp1.0", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "netcoreapp1.0"))),
+            ConfiguredProjectFactory.Create(null, new StandardProjectConfiguration("Debug|AnyCPU|net462", Empty.PropertiesMap
+                .Add("Configuration", "Debug")
+                .Add("Platform", "AnyCPU")
+                .Add("TargetFramework", "net462")))
+        ];
 
         var projectProperties = ProjectPropertiesFactory.Create(project, data, data2);
         var projectConfigProvider = new IActiveConfiguredProjectsProviderFactory(MockBehavior.Strict)
-                                   .ImplementGetActiveConfiguredProjectsMapAsync(projects);
+                                   .ImplementGetActiveConfiguredProjectsAsync(new ActiveConfiguredObjects<ConfiguredProject>(projects, ["TargetFramework"]));
 
         var commonServices = IUnconfiguredProjectCommonServicesFactory.Create(projectProperties: projectProperties);