sln-add: Support for slnx

src/Cli/dotnet/commands/dotnet-sln/LocalizableStrings.resx

@@ -184,9 +184,9 @@
     <value>.slnx file {0} generated.</value>
   </data>
   <data name="CannotMigrateSlnx" xml:space="preserve">
-    <value>Only .sln files can be migrated to .slnx format.</value>
+    <value>Cannot migrate .slnx file.</value>
   </data>
   <data name="SerializerNotFound" xml:space="preserve">
-    <value>Could not read solution file {0}. Supported files are .sln and .slnx valid solutions.</value>
+    <value>Could not find serializer for file {0}.</value>
   </data>
 </root>

src/Cli/dotnet/commands/dotnet-sln/add/Program.cs

@@ -2,143 +2,160 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+using Microsoft.Build.Construction;
+using Microsoft.Build.Exceptions;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
+using Microsoft.VisualStudio.SolutionPersistence;
+using Microsoft.VisualStudio.SolutionPersistence.Model;
+using Microsoft.VisualStudio.SolutionPersistence.Serializer.SlnV12;
 
 namespace Microsoft.DotNet.Tools.Sln.Add
 {
     internal class AddProjectToSolutionCommand : CommandBase
     {
         private readonly string _fileOrDirectory;
         private readonly bool _inRoot;
-        private readonly IList<string> _relativeRootSolutionFolders;
-        private readonly IReadOnlyCollection<string> _arguments;
+        private readonly IReadOnlyCollection<string> _projects;
+        private readonly string? _solutionFolderPath;
 
         public AddProjectToSolutionCommand(ParseResult parseResult) : base(parseResult)
         {
             _fileOrDirectory = parseResult.GetValue(SlnCommandParser.SlnArgument);
 
-            _arguments = parseResult.GetValue(SlnAddParser.ProjectPathArgument)?.ToArray() ?? (IReadOnlyCollection<string>)Array.Empty<string>();
+            _projects = parseResult.GetValue(SlnAddParser.ProjectPathArgument)?.ToArray() ?? (IReadOnlyCollection<string>)Array.Empty<string>();
 
             _inRoot = parseResult.GetValue(SlnAddParser.InRootOption);
-            string relativeRoot = parseResult.GetValue(SlnAddParser.SolutionFolderOption);
+            _solutionFolderPath = parseResult.GetValue(SlnAddParser.SolutionFolderOption);
 
-            SlnArgumentValidator.ParseAndValidateArguments(_fileOrDirectory, _arguments, SlnArgumentValidator.CommandType.Add, _inRoot, relativeRoot);
-
-            bool hasRelativeRoot = !string.IsNullOrEmpty(relativeRoot);
-
-            if (hasRelativeRoot)
-            {
-                relativeRoot = PathUtility.GetPathWithDirectorySeparator(relativeRoot);
-                _relativeRootSolutionFolders = relativeRoot.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries);
-            }
-            else
-            {
-                _relativeRootSolutionFolders = null;
-            }
+            SlnArgumentValidator.ParseAndValidateArguments(_fileOrDirectory, _projects, SlnArgumentValidator.CommandType.Add, _inRoot, _solutionFolderPath);
         }
 
         public override int Execute()
         {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
+            var solutionFileFullPath = SlnCommandParser.GetSlnFileFullPath(_fileOrDirectory);
 
-            var arguments = (_parseResult.GetValue<IEnumerable<string>>(SlnAddParser.ProjectPathArgument) ?? Array.Empty<string>()).ToList().AsReadOnly();
-            if (arguments.Count == 0)
+            if (_projects.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
             }
-
-            PathUtility.EnsureAllPathsExist(arguments, CommonLocalizableStrings.CouldNotFindProjectOrDirectory, true);
-
-            var fullProjectPaths = _arguments.Select(p =>
+            PathUtility.EnsureAllPathsExist(_projects, CommonLocalizableStrings.CouldNotFindProjectOrDirectory, true);
+            try
             {
-                var fullPath = Path.GetFullPath(p);
-                return Directory.Exists(fullPath) ?
-                    MsbuildProject.GetProjectFileFromDirectory(fullPath).FullName :
-                    fullPath;
-            }).ToList();
-
-            var preAddProjectCount = slnFile.Projects.Count;
-
-            foreach (var fullProjectPath in fullProjectPaths)
+                var fullProjectPaths = _projects.Select(project =>
+                {
+                    var fullPath = Path.GetFullPath(project);
+                    return Directory.Exists(fullPath) ? MsbuildProject.GetProjectFileFromDirectory(fullPath).FullName : fullPath;
+                });
+                AddProjectsToSolutionAsync(solutionFileFullPath, fullProjectPaths, CancellationToken.None).Wait();
+                return 0;
+            }
+            catch (GracefulException)
             {
-                // Identify the intended solution folders
-                var solutionFolders = DetermineSolutionFolder(slnFile, fullProjectPath);
-
-                slnFile.AddProject(fullProjectPath, solutionFolders);
+                throw;
             }
-
-            if (slnFile.Projects.Count > preAddProjectCount)
+            catch (Exception ex)
             {
-                slnFile.Write();
+                if (ex is SolutionException || ex.InnerException is SolutionException)
+                {
+                    throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, solutionFileFullPath, ex.Message);
+                }
+                throw new GracefulException(ex.Message, ex);
             }
-
-            return 0;
         }
 
-        private static IList<string> GetSolutionFoldersFromProjectPath(string projectFilePath)
+        private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)
         {
-            var solutionFolders = new List<string>();
-
-            if (!IsPathInTreeRootedAtSolutionDirectory(projectFilePath))
-                return solutionFolders;
-
-            var currentDirString = $".{Path.DirectorySeparatorChar}";
-            if (projectFilePath.StartsWith(currentDirString))
+            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);
+            SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);
+            // set UTF8 BOM encoding for .sln
+            if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)
             {
-                projectFilePath = projectFilePath.Substring(currentDirString.Length);
+                solution.SerializerExtension = v12Serializer.CreateModelExtension(new()
+                {
+                    Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true)
+                }); 
             }
-
-            var projectDirectoryPath = TrimProject(projectFilePath);
-            if (string.IsNullOrEmpty(projectDirectoryPath))
-                return solutionFolders;
-
-            var solutionFoldersPath = TrimProjectDirectory(projectDirectoryPath);
-            if (string.IsNullOrEmpty(solutionFoldersPath))
-                return solutionFolders;
-
-            solutionFolders.AddRange(solutionFoldersPath.Split(Path.DirectorySeparatorChar));
-
-            return solutionFolders;
+            SolutionFolderModel? solutionFolder = (!_inRoot && _solutionFolderPath != null)
+                ? solution.AddFolder(GetSolutionFolderPathWithForwardSlashes())
+                : null;
+            foreach (var projectPath in projectPaths)
+            {
+                // Get full project path
+                var relativePath = Path.GetRelativePath(Path.GetDirectoryName(solutionFileFullPath), projectPath);
+                try
+                {
+                    // Try to open the project to see if it is valid
+                    ProjectRootElement.Open(projectPath);
+                    AddProjectWithDefaultGuid(solution, relativePath, solutionFolder);
+                    Reporter.Output.WriteLine(CommonLocalizableStrings.ProjectAddedToTheSolution, relativePath);
+                }
+                catch (InvalidProjectFileException ex)
+                {
+                    Reporter.Error.WriteLine(string.Format(
+                        CommonLocalizableStrings.InvalidProjectWithExceptionMessage, projectPath, ex.Message));
+                }
+                catch (ArgumentException ex)
+                {
+                    // TODO: There are some cases where the project is not found but it already exists on the solution. So it is useful to check the error message. Will remove on future commit. 
+                    if (solution.FindProject(relativePath) != null || Regex.Match(ex.Message, @"Project name '.*' already exists in the solution folder.").Success)
+                    {
+                        Reporter.Output.WriteLine(CommonLocalizableStrings.SolutionAlreadyContainsProject, solutionFileFullPath, relativePath);
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+            AddDefaultProjectConfigurations(solution);
+            await serializer.SaveAsync(solutionFileFullPath, solution, cancellationToken);
         }
 
-        private IList<string> DetermineSolutionFolder(SlnFile slnFile, string fullProjectPath)
+        private void AddDefaultProjectConfigurations(SolutionModel solution)
         {
-            if (_inRoot)
+            string[] defaultConfigurationPlatforms = { "Any CPU", "x86", "x64" };
+            foreach (var platform in defaultConfigurationPlatforms)
             {
-                // The user requested all projects go to the root folder
-                return null;
+                solution.AddPlatform(platform);
             }
-
-            if (_relativeRootSolutionFolders != null)
+            string[] defaultConfigurationBuildTypes = { "Debug", "Release" };
+            foreach (var buildType in defaultConfigurationBuildTypes)
             {
-                // The user has specified an explicit root
-                return _relativeRootSolutionFolders;
+                solution.AddBuildType(buildType);
             }
-
-            // We determine the root for each individual project
-            var relativeProjectPath = Path.GetRelativePath(
-                PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory),
-                fullProjectPath);
-
-            return GetSolutionFoldersFromProjectPath(relativeProjectPath);
-        }
-
-        private static bool IsPathInTreeRootedAtSolutionDirectory(string path)
-        {
-            return !path.StartsWith("..");
+            solution.DistillProjectConfigurations();
         }
 
-        private static string TrimProject(string path)
+        private string GetSolutionFolderPathWithForwardSlashes()
         {
-            return Path.GetDirectoryName(path);
+            // SolutionModel::AddFolder expects path to have leading, trailing and inner forward slashes
+            return "/" + string.Join("/", PathUtility.GetPathWithDirectorySeparator(_solutionFolderPath).Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries)) + "/";
         }
 
-        private static string TrimProjectDirectory(string path)
+        private void AddProjectWithDefaultGuid(SolutionModel solution, string relativePath, SolutionFolderModel solutionFolder)
         {
-            return Path.GetDirectoryName(path);
+            SolutionProjectModel project;
+            try
+            {
+                solution.AddProject(relativePath, null, solutionFolder);
+            }
+            catch (ArgumentException ex)
+            {
+                // TODO: Update with error codes from vs-solutionpersistence
+                if (ex.Message == "ProjectType '' not found. (Parameter 'projectTypeName')")
+                {
+                    solution.AddProject(relativePath, "130159A9-F047-44B3-88CF-0CF7F02ED50F", solutionFolder);
+                }
+                else
+                {
+                    throw;
+                }
+            }
         }
     }
 }