Refactor existing renamer

Author: GrahamTheCoder

CodeConverter/Shared/SymbolRenamer.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ICSharpCode.CodeConverter.Util;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.FindSymbols;
+using Microsoft.CodeAnalysis.Rename;
+
+namespace ICSharpCode.CodeConverter.Shared
+{
+    internal static class SymbolRenamer
+    {
+        public static IEnumerable<(ISymbol Original, string NewName)> GetSymbolsWithNewNames(
+            IEnumerable<ISymbol> toRename, Func<string, bool> canUse, bool canKeepOne)
+        {
+            var symbolsWithNewNames = toRename.OrderByDescending(x => x.DeclaredAccessibility).ThenByDescending(x => x.Kind == SymbolKind.Parameter || x.Kind == SymbolKind.Property).Skip(canKeepOne ? 1 :0).Select(tr =>
+            {
+                string newName = NameGenerator.GenerateUniqueName(GetBaseName(tr), canUse);
+                return (Original: tr, NewName: newName);
+            });
+            return symbolsWithNewNames;
+        }
+
+        public static string GetName(ISymbol m) {
+            if (m.CanBeReferencedByName)
+                return m.Name;
+            if (m.ExplicitInterfaceImplementations().Any())
+                return m.Name.Split('.').Last();
+            return m.Name;
+        }
+
+        public static async Task<Project> PerformRenamesAsync(Project project, IReadOnlyCollection<(ISymbol Original, string NewName)> symbolsWithNewNames)
+        {
+            var solution = project.Solution;
+            foreach (var (originalSymbol, newName) in symbolsWithNewNames) {
+                project = solution.GetProject(project.Id);
+                var compilation = await project.GetCompilationAsync();
+                ISymbol currentDeclaration = SymbolFinder.FindSimilarSymbols(originalSymbol, compilation).FirstOrDefault();
+                if (currentDeclaration == null)
+                    continue; //Must have already renamed this symbol for a different reason
+                solution = await Renamer.RenameSymbolAsync(solution, currentDeclaration, newName, solution.Workspace.Options);
+            }
+
+            return solution.GetProject(project.Id);
+        }
+
+        private static string GetBaseName(ISymbol declaration)
+        {
+            string prefix = declaration.Kind.ToString().ToLowerInvariant()[0] + "_";
+            string name = GetName(declaration);
+            return prefix + name.Substring(0, 1).ToUpperInvariant() + name.Substring(1);
+        }
+
+        public static IEnumerable<INamespaceOrTypeSymbol> GetNamespacesAndTypesInAssembly(Project project, Compilation compilation)
+        {
+            return compilation.GlobalNamespace.FollowProperty((INamespaceOrTypeSymbol n) => n.GetMembers().OfType<INamespaceOrTypeSymbol>().Where(s => s.IsDefinedInSource() && s?.ContainingAssembly?.Name == project.AssemblyName));
+        }
+
+        public static IEnumerable<(ISymbol Original, string NewName)> GetSymbolsWithNewNames(IReadOnlyCollection<ISymbol> symbolGroup, HashSet<string> names, bool caseSensitive)
+        {
+            var canRename = symbolGroup.Where(s => s.IsDefinedInSource() && s.CanBeReferencedByName).ToArray();
+            var specialSymbolUsingName = canRename.Length < symbolGroup.Count;
+            var methodSymbols = canRename.OfType<IMethodSymbol>().ToArray();
+            var canKeepOneNormalMemberName = !specialSymbolUsingName && !methodSymbols.Any();
+            symbolGroup = canRename.Except(methodSymbols).ToArray();
+            (ISymbol Original, string NewName)[] methodsWithNewNames = GetMethodSymbolsWithNewNames(methodSymbols.ToArray(), names, specialSymbolUsingName, caseSensitive);
+            return GetSymbolsWithNewNames(symbolGroup, names.Add, canKeepOneNormalMemberName).Concat(methodsWithNewNames);
+        }
+
+        private static (ISymbol Original, string NewName)[] GetMethodSymbolsWithNewNames(IMethodSymbol[] methodSymbols,
+            HashSet<string> names,
+            bool specialSymbolUsingName, bool caseSensitive)
+        {
+            var stringComparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
+            var methodsBySignature = methodSymbols
+                .ToLookup(m => m.GetUnqualifiedMethodSignature(caseSensitive))
+                .Where(g => g.Count() > 1)
+                .SelectMany(clashingMethodGroup =>
+                {
+                    var thisMethodGroupNames = new HashSet<string>(stringComparer);
+                    var symbolsWithNewNames = GetSymbolsWithNewNames(clashingMethodGroup,
+                        n => !names.Contains(n) && thisMethodGroupNames.Add(n),
+                        !specialSymbolUsingName).ToArray();
+                    return symbolsWithNewNames;
+                }).ToArray();
+
+            foreach (var newMethodNames in methodsBySignature.Select(m => m.NewName))
+            {
+                names.Add(newMethodNames);
+            }
+
+            return methodsBySignature;
+        }
+    }
+}

CodeConverter/VB/CSToVBProjectContentsConverter.cs

@@ -52,7 +52,7 @@ public CSToVBProjectContentsConverter(ConversionOptions conversionOptions, IProg
         public async Task InitializeSourceAsync(Project project)
         {
             // TODO: Don't throw away solution-wide effects - write them to referencing files, and use in conversion of any other projects being converted at the same time.
-            project = await CaseConflictResolver.RenameClashingSymbolsAsync(project);
+            project = await ClashingMemberRenamer.RenameClashingSymbolsAsync(project);
             _sourceCsProject = project;
             _convertedVbProject = project.ToProjectFromAnyOptions(_vbCompilationOptions, _vbParseOptions);
             _vbReferenceProject = project.CreateReferenceOnlyProjectFromAnyOptions(_vbCompilationOptions, _vbParseOptions);

CodeConverter/VB/CaseConflictResolver.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ICSharpCode.CodeConverter.Shared;
+using ICSharpCode.CodeConverter.Util;
+using Microsoft.CodeAnalysis;
+
+namespace ICSharpCode.CodeConverter.VB
+{
+    internal static class ClashingMemberRenamer
+    {
+        /// <summary>
+        /// Renames symbols in a CSharp project so that they don't clash on case within the same named scope, attempting to rename the least public ones first.
+        /// This is because C# is case sensitive but VB is case insensitive.
+        /// </summary>
+        /// <remarks>
+        /// Cases in different named scopes should be dealt with by <seealso cref="DocumentExtensions.ExpandAsync"/>.
+        /// For names scoped within a type member, see <seealso cref="SemanticModelSymbolSetExtensions.GetCsLocalSymbolsPerScope"/>.
+        /// </remarks>
+        public static async Task<Project> RenameClashingSymbolsAsync(Project project)
+        {
+            var compilation = await project.GetCompilationAsync();
+            var memberRenames = SymbolRenamer.GetNamespacesAndTypesInAssembly(project, compilation)
+                .SelectMany(x => GetSymbolsWithNewNames(x, compilation));
+            return await SymbolRenamer.PerformRenamesAsync(project, memberRenames.ToList());
+        }
+
+        private static IEnumerable<(ISymbol Original, string NewName)> GetSymbolsWithNewNames(INamespaceOrTypeSymbol containerSymbol, Compilation compilation)
+        {
+            var members = containerSymbol.GetMembers().Where(m => m.Locations.Any(loc => loc.SourceTree != null && compilation.ContainsSyntaxTree(loc.SourceTree))).ToArray();
+            var symbolSets = GetLocalSymbolSets(containerSymbol, compilation, members).Concat(members.AsEnumerable().Yield());
+            return symbolSets.SelectMany(GetUniqueNamesForSymbolSet);
+        }
+
+        public static IEnumerable<IEnumerable<ISymbol>> GetLocalSymbolSets(INamespaceOrTypeSymbol containerSymbol, Compilation compilation, IReadOnlyCollection<ISymbol> members)
+        {
+            if (!(containerSymbol is ITypeSymbol)) return Enumerable.Empty<IEnumerable<ISymbol>>();
+
+            var semanticModels = containerSymbol.Locations.Select(loc => loc.SourceTree).Distinct()
+                .Where(compilation.ContainsSyntaxTree)
+                .Select(sourceTree => compilation.GetSemanticModel(sourceTree, true));
+            return semanticModels.SelectMany(semanticModel => members.SelectMany(semanticModel.GetCsSymbolsPerScope));
+        }
+
+        private static IEnumerable<(ISymbol Original, string NewName)> GetUniqueNamesForSymbolSet(IEnumerable<ISymbol> symbols) {
+            var membersByCaseInsensitiveName = symbols.ToLookup(SymbolRenamer.GetName, m => m, StringComparer.OrdinalIgnoreCase);
+            var names = new HashSet<string>(membersByCaseInsensitiveName.Select(ms => ms.Key),
+                StringComparer.OrdinalIgnoreCase);
+            var symbolsWithNewNames = membersByCaseInsensitiveName.Where(ms => ms.Count() > 1)
+                .SelectMany(symbolGroup => SymbolRenamer.GetSymbolsWithNewNames(symbolGroup.ToArray(), names, false));
+            return symbolsWithNewNames;
+        }
+    }
+}