Merge pull request #721 from StealthyDeveloper/master

Projectnames with a suffix equal to other projects unjustly converted.

Author: GrahamTheCoder

CodeConverter/CodeConverter.csproj

@@ -4,13 +4,14 @@
     <AssemblyName>ICSharpCode.CodeConverter</AssemblyName>
     <RootNamespace>ICSharpCode.CodeConverter</RootNamespace>
     <Company>ICSharpCode</Company>
-    <Description>Convert VB.NET to/from C#
-* Accurate: Full project context (through Roslyn) is used to get the most accurate conversion.
-* Actively developed: User feedback helps us continuously strive for a more accurate conversion.
-* Completely free and open source
-This nuget package is useful if you're building a tool which converts code, or if you want finer-grained control over what's converted.
-See https://github.com/icsharpcode/CodeConverter for a pre-built command line, visual studio extension and web converter.
-</Description>
+    <Description>
+      Convert VB.NET to/from C#
+      * Accurate: Full project context (through Roslyn) is used to get the most accurate conversion.
+      * Actively developed: User feedback helps us continuously strive for a more accurate conversion.
+      * Completely free and open source
+      This nuget package is useful if you're building a tool which converts code, or if you want finer-grained control over what's converted.
+      See https://github.com/icsharpcode/CodeConverter for a pre-built command line, visual studio extension and web converter.
+    </Description>
     <Product>Code Converter for C# to/from VB.NET</Product>
     <Copyright>Copyright (c) 2017-2020 AlphaSierraPapa for the CodeConverter team</Copyright>
     <AssemblyVersion>8.2.4.0</AssemblyVersion>
@@ -46,6 +47,7 @@ See https://github.com/icsharpcode/CodeConverter for a pre-built command line, v
     <PackageReference Include="Microsoft.VisualStudio.Composition" Version="15.8.98" />
     <PackageReference Include="Microsoft.VisualStudio.Threading" Version="15.8.122" />
     <PackageReference Include="System.Globalization.Extensions" Version="4.3.0" />
+    <PackageReference Include="System.IO.Abstractions" Version="13.2.33" />
     <PackageReference Include="System.Linq.Async" Version="4.0.0" />
     <PackageReference Include="System.Threading.Tasks.Dataflow" Version="4.6.0">
       <IncludeAssets>all</IncludeAssets>

CodeConverter/Shared/ISolutionFileTextEditor.cs

@@ -0,0 +1,10 @@
+namespace ICSharpCode.CodeConverter.Shared
+{
+    using System.Collections.Generic;
+
+    public interface ISolutionFileTextEditor
+    {
+        List<(string Find, string Replace, bool FirstOnly)> GetProjectFileProjectReferenceReplacements(
+            IEnumerable<(string Name, string RelativeProjPath, string ProjContents)> projTuples, string sourceSolutionContents);
+    }
+}

CodeConverter/Shared/PathConverter.cs

@@ -33,5 +33,13 @@ private static string GetConvertedExtension(string originalExtension)
                     return originalExtension;
             }
         }
+
+        public static string GetRelativePath(string relativeTo, string path)
+        {
+            var uri = new Uri(relativeTo);
+            var rel = Uri.UnescapeDataString(uri.MakeRelativeUri(new Uri(path)).ToString()).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+
+            return rel;
+        }
     }
 }

CodeConverter/Shared/ProjectConversion.cs

@@ -10,10 +10,11 @@
 using ICSharpCode.CodeConverter.CSharp;
 using ICSharpCode.CodeConverter.Util;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Text;
-
 namespace ICSharpCode.CodeConverter.Shared
 {
+    using System.IO.Abstractions;
+    using Microsoft.CodeAnalysis.Text;
+
     public class ProjectConversion
     {
         private readonly IProjectContentsConverter _projectContentsConverter;
@@ -22,7 +23,7 @@ public class ProjectConversion
         private readonly ILanguageConversion _languageConversion;
         private readonly bool _showCompilationErrors;
         private readonly bool _returnSelectedNode;
-        private static readonly string[] BannedPaths = new[] { ".AssemblyAttributes.", "\\bin\\", "\\obj\\" };
+        private static readonly string[] BannedPaths = { ".AssemblyAttributes.", "\\bin\\", "\\obj\\" };
         private readonly CancellationToken _cancellationToken;
 
         private ProjectConversion(IProjectContentsConverter projectContentsConverter, IEnumerable<Document> documentsToConvert, IEnumerable<TextDocument> additionalDocumentsToConvert,

CodeConverter/Shared/SolutionConverter.cs

@@ -2,11 +2,11 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.Util;
 using Microsoft.CodeAnalysis;
+using System.IO.Abstractions;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -18,32 +18,58 @@ public class SolutionConverter
         private readonly List<(string Find, string Replace, bool FirstOnly)> _projectReferenceReplacements;
         private readonly IProgress<ConversionProgress> _progress;
         private readonly ILanguageConversion _languageConversion;
+        private readonly SolutionFileTextEditor _solutionFileTextEditor;
         private readonly CancellationToken _cancellationToken;
 
+        public static IFileSystem FileSystem { get; set; } = new FileSystem();
+
+        public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert, string sourceSolutionContents)
+            where TLanguageConversion : ILanguageConversion, new()
+        {
+            return CreateFor<TLanguageConversion>(projectsToConvert, solutionContents: sourceSolutionContents);
+        }
+
         public static SolutionConverter CreateFor<TLanguageConversion>(IReadOnlyCollection<Project> projectsToConvert,
             ConversionOptions conversionOptions = default,
             IProgress<ConversionProgress> progress = null,
-            CancellationToken cancellationToken = default) where TLanguageConversion : ILanguageConversion, new()
+            CancellationToken cancellationToken = default,
+            string solutionContents = "") where TLanguageConversion : ILanguageConversion, new()
         {
-            var conversion = new TLanguageConversion {ConversionOptions = conversionOptions };
-            return CreateFor(conversion, projectsToConvert, progress, cancellationToken);
+            var conversion = new TLanguageConversion { ConversionOptions = conversionOptions };
+            return CreateFor(conversion, projectsToConvert, progress, cancellationToken, solutionContents);
         }
 
         public static SolutionConverter CreateFor(ILanguageConversion languageConversion, IReadOnlyCollection<Project> projectsToConvert,
             IProgress<ConversionProgress> progress,
-            CancellationToken cancellationToken)
+            CancellationToken cancellationToken, string solutionContents = "")
         {
             languageConversion.ConversionOptions ??= new ConversionOptions();
             var solutionFilePath = projectsToConvert.First().Solution.FilePath;
-            var sourceSolutionContents = File.Exists(solutionFilePath) ? File.ReadAllText(solutionFilePath) : "";
-            var projectReferenceReplacements = GetProjectReferenceReplacements(projectsToConvert, sourceSolutionContents);
-            return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements, progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion);
+            var sourceSolutionContents = File.Exists(solutionFilePath)
+                ? FileSystem.File.ReadAllText(solutionFilePath)
+                : solutionContents;
+
+            var projTuples = projectsToConvert.Select(proj =>
+            {
+                var relativeProjPath = PathConverter.GetRelativePath(solutionFilePath, proj.FilePath);
+                var projContents = FileSystem.File.ReadAllText(proj.FilePath);
+
+                return (proj.Name, RelativeProjPath: relativeProjPath, ProjContents: projContents);
+            });
+
+            var solutionFileTextEditor = new SolutionFileTextEditor();
+            var projectReferenceReplacements = solutionFileTextEditor.GetProjectFileProjectReferenceReplacements(projTuples, sourceSolutionContents);
+
+            return new SolutionConverter(solutionFilePath, sourceSolutionContents, projectsToConvert, projectReferenceReplacements,
+                progress ?? new Progress<ConversionProgress>(), cancellationToken, languageConversion, solutionFileTextEditor);
         }
 
         private SolutionConverter(string solutionFilePath,
             string sourceSolutionContents, IReadOnlyCollection<Project> projectsToConvert,
-            List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements, IProgress<ConversionProgress> showProgressMessage,
-            CancellationToken cancellationToken, ILanguageConversion languageConversion)
+            List<(string Find, string Replace, bool FirstOnly)> projectReferenceReplacements,
+            IProgress<ConversionProgress> showProgressMessage,
+            CancellationToken cancellationToken, ILanguageConversion languageConversion,
+            SolutionFileTextEditor solutionFileTextEditor)
         {
             _solutionFilePath = solutionFilePath;
             _sourceSolutionContents = sourceSolutionContents;
@@ -52,15 +78,18 @@ private SolutionConverter(string solutionFilePath,
             _progress = showProgressMessage;
             _languageConversion = languageConversion;
             _cancellationToken = cancellationToken;
+            _solutionFileTextEditor = solutionFileTextEditor;
         }
 
-        public async Task<IAsyncEnumerable<ConversionResult>> Convert()
+        public async IAsyncEnumerable<ConversionResult> Convert()
         {
             var projectsToUpdateReferencesOnly = _projectsToConvert.First().Solution.Projects.Except(_projectsToConvert);
             var solutionResult = string.IsNullOrWhiteSpace(_sourceSolutionContents) ? Enumerable.Empty<ConversionResult>() : ConvertSolutionFile().Yield();
             var convertedProjects = await ConvertProjects();
-            return convertedProjects
-                .Concat(UpdateProjectReferences(projectsToUpdateReferencesOnly).Concat(solutionResult).ToAsyncEnumerable());
+            var projectsAndSolutionResults = UpdateProjectReferences(projectsToUpdateReferencesOnly).Concat(solutionResult).ToAsyncEnumerable();
+            await foreach (var p in convertedProjects.Concat(projectsAndSolutionResults)) {
+                yield return p;
+            }
         }
 
         private async Task<IAsyncEnumerable<ConversionResult>> ConvertProjects()
@@ -79,63 +108,32 @@ private IAsyncEnumerable<ConversionResult> ConvertProject(Project project, IEnum
 
         private IEnumerable<ConversionResult> UpdateProjectReferences(IEnumerable<Project> projectsToUpdateReferencesOnly)
         {
-            return projectsToUpdateReferencesOnly
-                .Where(p => p.FilePath != null) //Some project types like Websites don't have a project file
-                .Select(project => {
+            var conversionResults = projectsToUpdateReferencesOnly
+               .Where(p => p.FilePath != null) //Some project types like Websites don't have a project file
+               .Select(project => {
                     var withReferencesReplaced =
                         new FileInfo(project.FilePath).ConversionResultFromReplacements(_projectReferenceReplacements);
                     withReferencesReplaced.TargetPathOrNull = withReferencesReplaced.SourcePathOrNull;
                     return withReferencesReplaced;
-                }).Where(c => !c.IsIdentity);
-        }
+                });
 
-        private static List<(string Find, string Replace, bool FirstOnly)> GetProjectReferenceReplacements(IReadOnlyCollection<Project> projectsToConvert,
-            string sourceSolutionContents)
-        {
-            var projectReferenceReplacements = new List<(string Find, string Replace, bool FirstOnly)>();
-            foreach (var project in projectsToConvert)
-            {
-                var projFilename = Path.GetFileName(project.FilePath);
-                var newProjFilename = PathConverter.TogglePathExtension(projFilename);
-                projectReferenceReplacements.Add((projFilename, newProjFilename, false));
-                if (!string.IsNullOrWhiteSpace(sourceSolutionContents)) projectReferenceReplacements.Add(GetProjectGuidReplacement(projFilename, sourceSolutionContents));
-            }
-
-            return projectReferenceReplacements;
+            return conversionResults.Where(c => !c.IsIdentity);
         }
 
-        private ConversionResult ConvertSolutionFile()
+        public ConversionResult ConvertSolutionFile()
         {
             var projectTypeGuidMappings = _languageConversion.GetProjectTypeGuidMappings();
-            var projectTypeReplacements = _projectsToConvert.SelectMany(project => GetProjectTypeReplacement(project, projectTypeGuidMappings)).ToList();
+            var relativeProjPaths = _projectsToConvert.Select(proj =>
+                (proj.Name, RelativeProjPath: PathConverter.GetRelativePath(_solutionFilePath, proj.FilePath)));
+
+            var slnProjectReferenceReplacements = _solutionFileTextEditor.GetSolutionFileProjectReferenceReplacements(relativeProjPaths,
+                _sourceSolutionContents, projectTypeGuidMappings);
 
-            var convertedSolutionContents = _sourceSolutionContents.Replace(_projectReferenceReplacements.Concat(projectTypeReplacements));
+            var convertedSolutionContents = _sourceSolutionContents.Replace(slnProjectReferenceReplacements);
             return new ConversionResult(convertedSolutionContents) {
                 SourcePathOrNull = _solutionFilePath,
                 TargetPathOrNull = _solutionFilePath
             };
         }
-
-        private static (string Find, string Replace, bool FirstOnly) GetProjectGuidReplacement(string projFilename, string contents)
-        {
-            var projGuidRegex = new Regex(projFilename + @""", ""({[0-9A-Fa-f\-]{32,36}})("")");
-            var projGuidMatch = projGuidRegex.Match(contents);
-            var oldGuid = projGuidMatch.Groups[1].Value;
-            var newGuid = GetDeterministicGuidFrom(new Guid(oldGuid));
-            return (oldGuid, newGuid.ToString("B").ToUpperInvariant(), false);
-        }
-
-        private IEnumerable<(string, string, bool)> GetProjectTypeReplacement(Project project, IReadOnlyCollection<(string, string)> typeGuidMappings)
-        {
-            return typeGuidMappings.Select(guidReplacement => ($@"Project\s*\(\s*""{guidReplacement.Item1}""\s*\)\s*=\s*""{project.Name}""", $@"Project(""{guidReplacement.Item2}"") = ""{project.Name}""", false));
-        }
-
-        private static Guid GetDeterministicGuidFrom(Guid guidToConvert)
-        {
-            var codeConverterStaticGuid = new Guid("{B224816B-CC58-4FF1-8258-CA7E629734A0}");
-            var deterministicNewBytes = codeConverterStaticGuid.ToByteArray().Zip(guidToConvert.ToByteArray(),
-                (fromFirst, fromSecond) => (byte)(fromFirst ^ fromSecond));
-            return new Guid(deterministicNewBytes.ToArray());
-        }
     }
 }