Map solution configurations to existing project configurations on add.

This commit implements solution configuration to project configuration mapping.

Previously, when a project was added to the solution with the `sln add`
command, solution configurations would be mapped to a project configuration and
platform of the same name, regardless of whether or not the project had a
configuration or platform of that name.  This caused the solution to appear
dirty when opened in Visual Studio if the configuration or platform did not
exist at the project level because Visual Studio would attempt to correct the
mapping.

The fix is to check what configurations and platforms are supported by the
project and only map to what is present.  If a solution configuration can't be
mapped, the first configuration/platform supported by the project is chosen;
this is consistent with how Visual Studio does the fallback mapping.

Fixes #6221.

Author: Peter Huene

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/App.sln

@@ -0,0 +1,21 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26006.2
+MinimumVisualStudioVersion = 10.0.40219.1
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|Any CPU = Release|Any CPU
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+		Foo Bar|Any CPU = Foo Bar|Any CPU
+		Foo Bar|x64 = Foo Bar|x64
+		Foo Bar|x86 = Foo Bar|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithAdditionalConfigs/Library.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace ProjectWithAdditionalConfigs
+{
+    public static class Library
+    {
+        public static string GetMessage()
+        {
+            return "Hello World!";
+        }
+    }
+}

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithAdditionalConfigs/ProjectWithAdditionalConfigs.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <ProjectGuid>{A302325B-D680-4C0E-8680-7AE283981624}</ProjectGuid>
+    <Platforms>AnyCPU;x64;x86;AdditionalPlatform</Platforms>
+    <Configurations>Debug;Release;FooBar;AdditionalConfiguration</Configurations>
+  </PropertyGroup>
+
+</Project>

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithMatchingConfigs/Library.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace ProjectWithMatchingConfigs
+{
+    public static class Library
+    {
+        public static string GetMessage()
+        {
+            return "Hello World!";
+        }
+    }
+}

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithMatchingConfigs/ProjectWithMatchingConfigs.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <ProjectGuid>{C9601CA2-DB64-4FB6-B463-368C7764BF0D}</ProjectGuid>
+    <Platforms>AnyCPU;x64;x86</Platforms>
+    <Configurations>Debug;Release;FooBar</Configurations>
+  </PropertyGroup>
+
+</Project>

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithoutMatchingConfigs/Library.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace ProjectWithoutMatchingConfigs
+{
+    public static class Library
+    {
+        public static string GetMessage()
+        {
+            return "Hello World!";
+        }
+    }
+}

TestAssets/TestProjects/TestAppWithSlnAndProjectConfigs/ProjectWithoutMatchingConfigs/ProjectWithoutMatchingConfigs.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <ProjectGuid>{C49B64DE-4401-4825-8A88-10DCB5950E57}</ProjectGuid>
+  </PropertyGroup>
+
+</Project>

src/dotnet/ProjectInstanceExtensions.cs

@@ -4,6 +4,7 @@
 using Microsoft.Build.Execution;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Microsoft.DotNet.Tools.Common
@@ -45,5 +46,25 @@ public static string GetProjectTypeGuid(this ProjectInstance projectInstance)
 
             return projectTypeGuid;
         }
+
+        public static IEnumerable<string> GetPlatforms(this ProjectInstance projectInstance)
+        {
+            return (projectInstance.GetPropertyValue("Platforms") ?? "")
+                .Split(
+                    new char[] { ';' },
+                    StringSplitOptions.RemoveEmptyEntries)
+                .Where(p => !string.IsNullOrWhiteSpace(p))
+                .DefaultIfEmpty("AnyCPU");
+        }
+
+        public static IEnumerable<string> GetConfigurations(this ProjectInstance projectInstance)
+        {
+            return (projectInstance.GetPropertyValue("Configurations") ?? "Debug;Release")
+                .Split(
+                    new char[] { ';' },
+                    StringSplitOptions.RemoveEmptyEntries)
+                .Where(c => !string.IsNullOrWhiteSpace(c))
+                .DefaultIfEmpty("Debug");
+        }
     }
 }

src/dotnet/SlnFileExtensions.cs

@@ -59,7 +59,16 @@ public static void AddProject(this SlnFile slnFile, string fullProjectPath)
                     FilePath = relativeProjectPath
                 };
 
-                slnFile.AddDefaultBuildConfigurations(slnProject);
+                // NOTE: The order you create the sections determines the order they are written to the sln
+                // file. In the case of an empty sln file, in order to make sure the solution configurations
+                // section comes first we need to add it first. This doesn't affect correctness but does
+                // stop VS from re-ordering things later on. Since we are keeping the SlnFile class low-level
+                // it shouldn't care about the VS implementation details. That's why we handle this here.
+                slnFile.AddDefaultBuildConfigurations();
+
+                slnFile.MapSolutionConfigurationsToProject(
+                    projectInstance,
+                    slnFile.ProjectConfigurationsSection.GetOrCreatePropertySet(slnProject.Id));
 
                 slnFile.AddSolutionFolders(slnProject);
 
@@ -70,11 +79,13 @@ public static void AddProject(this SlnFile slnFile, string fullProjectPath)
             }
         }
 
-        public static void AddDefaultBuildConfigurations(this SlnFile slnFile, SlnProject slnProject)
+        private static void AddDefaultBuildConfigurations(this SlnFile slnFile)
         {
-            if (slnProject == null)
+            var configurationsSection = slnFile.SolutionConfigurationsSection;
+
+            if (!configurationsSection.IsEmpty)
             {
-                throw new ArgumentException();
+                return;
             }
 
             var defaultConfigurations = new List<string>()
@@ -87,57 +98,108 @@ public static void AddDefaultBuildConfigurations(this SlnFile slnFile, SlnProjec
                 "Release|x86",
             };
 
-            // NOTE: The order you create the sections determines the order they are written to the sln
-            // file. In the case of an empty sln file, in order to make sure the solution configurations
-            // section comes first we need to add it first. This doesn't affect correctness but does 
-            // stop VS from re-ordering things later on. Since we are keeping the SlnFile class low-level
-            // it shouldn't care about the VS implementation details. That's why we handle this here.
-            AddDefaultSolutionConfigurations(defaultConfigurations, slnFile.SolutionConfigurationsSection);
-            AddDefaultProjectConfigurations(
-                defaultConfigurations,
-                slnFile.ProjectConfigurationsSection.GetOrCreatePropertySet(slnProject.Id));
-        }
-
-        private static void AddDefaultSolutionConfigurations(
-            List<string> defaultConfigurations,
-            SlnPropertySet solutionConfigs)
-        {
             foreach (var config in defaultConfigurations)
             {
-                if (!solutionConfigs.ContainsKey(config))
-                {
-                    solutionConfigs[config] = config;
-                }
+                configurationsSection[config] = config;
             }
         }
 
-        private static void AddDefaultProjectConfigurations(
-            List<string> defaultConfigurations,
-            SlnPropertySet projectConfigs)
+        private static void MapSolutionConfigurationsToProject(
+            this SlnFile slnFile,
+            ProjectInstance projectInstance,
+            SlnPropertySet solutionProjectConfigs)
         {
-            foreach (var config in defaultConfigurations)
+            var (projectConfigurations, defaultProjectConfiguration) = GetKeysDictionary(projectInstance.GetConfigurations());
+            var (projectPlatforms, defaultProjectPlatform) = GetKeysDictionary(projectInstance.GetPlatforms());
+
+            foreach (var solutionConfigKey in slnFile.SolutionConfigurationsSection.Keys)
             {
-                var activeCfgKey = $"{config}.ActiveCfg";
-                if (!projectConfigs.ContainsKey(activeCfgKey))
+                var projectConfigKey = MapSolutionConfigKeyToProjectConfigKey(
+                    solutionConfigKey,
+                    projectConfigurations,
+                    defaultProjectConfiguration,
+                    projectPlatforms,
+                    defaultProjectPlatform);
+                if (projectConfigKey == null)
                 {
-                    projectConfigs[activeCfgKey] = config;
+                    continue;
                 }
 
-                var build0Key = $"{config}.Build.0";
-                if (!projectConfigs.ContainsKey(build0Key))
+                var activeConfigKey = $"{solutionConfigKey}.ActiveCfg";
+                if (!solutionProjectConfigs.ContainsKey(activeConfigKey))
                 {
-                    projectConfigs[build0Key] = config;
+                    solutionProjectConfigs[activeConfigKey] = projectConfigKey;
+                }
+
+                var buildKey = $"{solutionConfigKey}.Build.0";
+                if (!solutionProjectConfigs.ContainsKey(buildKey))
+                {
+                    solutionProjectConfigs[buildKey] = projectConfigKey;
                 }
             }
         }
 
-        public static void AddSolutionFolders(this SlnFile slnFile, SlnProject slnProject)
+        private static (Dictionary<string, string> Keys, string DefaultKey) GetKeysDictionary(IEnumerable<string> keys)
         {
-            if (slnProject == null)
+            // A dictionary mapping key -> key is used instead of a HashSet so the original case of the key can be retrieved from the set
+            var dictionary = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
+
+            foreach (var key in keys)
             {
-                throw new ArgumentException();
+                dictionary[key] = key;
+            }
+
+            return (dictionary, keys.FirstOrDefault());
+        }
+
+        private static string GetMatchingProjectKey(IDictionary<string, string> projectKeys, string solutionKey)
+        {
+            string projectKey;
+            if (projectKeys.TryGetValue(solutionKey, out projectKey))
+            {
+                return projectKey;
+            }
+
+            var keyWithoutWhitespace = String.Concat(solutionKey.Where(c => !Char.IsWhiteSpace(c)));
+            if (projectKeys.TryGetValue(keyWithoutWhitespace, out projectKey))
+            {
+                return projectKey;
+            }
+
+            return null;
+        }
+
+        private static string MapSolutionConfigKeyToProjectConfigKey(
+            string solutionConfigKey,
+            Dictionary<string, string> projectConfigurations,
+            string defaultProjectConfiguration,
+            Dictionary<string, string> projectPlatforms,
+            string defaultProjectPlatform)
+        {
+            var pair = solutionConfigKey.Split(new char[] {'|'}, 2);
+            if (pair.Length != 2)
+            {
+                return null;
+            }
+
+            var projectConfiguration = GetMatchingProjectKey(projectConfigurations, pair[0]) ?? defaultProjectConfiguration;
+            if (projectConfiguration == null)
+            {
+                return null;
+            }
+
+            var projectPlatform = GetMatchingProjectKey(projectPlatforms, pair[1]) ?? defaultProjectPlatform;
+            if (projectPlatform == null)
+            {
+                return null;
             }
 
+            // VS stores "Any CPU" platform in the solution regardless of how it is named at the project level
+            return $"{projectConfiguration}|{(projectPlatform == "AnyCPU" ? "Any CPU" : projectPlatform)}";
+        }
+
+        private static void AddSolutionFolders(this SlnFile slnFile, SlnProject slnProject)
+        {
             var solutionFolders = slnProject.GetSolutionFoldersFromProject();
 
             if (solutionFolders.Any())