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,145 @@
 // 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 (SolutionException ex)
             {
-                slnFile.Write();
+                throw new GracefulException(CommonLocalizableStrings.InvalidSolutionFormatString, solutionFileFullPath, ex.Message);
             }
-
-            return 0;
-        }
-
-        private static IList<string> GetSolutionFoldersFromProjectPath(string projectFilePath)
-        {
-            var solutionFolders = new List<string>();
-
-            if (!IsPathInTreeRootedAtSolutionDirectory(projectFilePath))
-                return solutionFolders;
-
-            var currentDirString = $".{Path.DirectorySeparatorChar}";
-            if (projectFilePath.StartsWith(currentDirString))
+            catch (Exception ex)
             {
-                projectFilePath = projectFilePath.Substring(currentDirString.Length);
+                throw new GracefulException(ex.Message, ex);
             }
-
-            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;
         }
 
-        private IList<string> DetermineSolutionFolder(SlnFile slnFile, string fullProjectPath)
+        private async Task AddProjectsToSolutionAsync(string solutionFileFullPath, IEnumerable<string> projectPaths, CancellationToken cancellationToken)
         {
-            if (_inRoot)
+            ISolutionSerializer serializer = SlnCommandParser.GetSolutionSerializer(solutionFileFullPath);
+            SolutionModel solution = await serializer.OpenAsync(solutionFileFullPath, cancellationToken);
+            // set UTF8 BOM encoding for .sln
+            if (serializer is ISolutionSerializer<SlnV12SerializerSettings> v12Serializer)
             {
-                // The user requested all projects go to the root folder
-                return null;
+                solution.SerializerExtension = v12Serializer.CreateModelExtension(new()
+                {
+                    Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true)
+                }); 
             }
-
-            if (_relativeRootSolutionFolders != null)
+            SolutionFolderModel? solutionFolder = (!_inRoot && _solutionFolderPath != null)
+                ? solution.AddFolder(GetSolutionFolderPathWithForwardSlashes())
+                : null;
+            foreach (var projectPath in projectPaths)
             {
-                // The user has specified an explicit root
-                return _relativeRootSolutionFolders;
+                // 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 project = ProjectRootElement.Open(projectPath);
+                    AddProjectWithDefaultGuid(solution, relativePath, solutionFolder, project.GetProjectTypeGuid());
+                    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;
+                    }
+                }
             }
-
-            // 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();
+            await serializer.SaveAsync(solutionFileFullPath, solution, cancellationToken);
         }
 
-        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, string guid)
         {
-            return Path.GetDirectoryName(path);
+            SolutionProjectModel project;
+            try
+            {
+                solution.AddProject(relativePath, guid, 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;
+                }
+            }
         }
     }
 }