PR comments

src/Workspaces/Core/Portable/Rename/ConflictEngine/ConflictResolver.cs

@@ -181,20 +181,23 @@ private static bool IsRenameValid(ConflictResolution conflictResolution, ISymbol
         {
             try
             {
+                var project = conflictResolution.NewSolution.GetProject(renamedSymbol.ContainingAssembly, cancellationToken);
+
                 if (renamedSymbol.ContainingSymbol.IsKind(SymbolKind.NamedType))
                 {
                     var otherThingsNamedTheSame = renamedSymbol.ContainingType.GetMembers(renamedSymbol.Name)
                                                            .Where(s => !s.Equals(renamedSymbol) &&
                                                                        string.Equals(s.MetadataName, renamedSymbol.MetadataName, StringComparison.Ordinal));
 
-                    // excluded Method or Property(only for VB) here, as they may have the same name but different parameters
                     IEnumerable<ISymbol> otherThingsNamedTheSameExcludeMethodAndParameterizedProperty;
-                    if (renamedSymbol.Language == LanguageNames.VisualBasic)
+
+                    // Possibly overloaded symbols are excluded here and handled elsewhere
+                    var semanticFactsService = project.LanguageServices.GetService<ISemanticFactsService>();
+                    if (semanticFactsService.SupportsParameterizedProperties)
                     {
-                        // Only VB allows Parameterized Properties
                         otherThingsNamedTheSameExcludeMethodAndParameterizedProperty = otherThingsNamedTheSame
-                            .Where(s=> (s.Kind != SymbolKind.Method && s.Kind != SymbolKind.Property) ||
-                            (renamedSymbol.Kind != SymbolKind.Method && renamedSymbol.Kind != SymbolKind.Property));
+                            .Where(s=> !s.MatchesKind(SymbolKind.Method, SymbolKind.Property) ||
+                                !renamedSymbol.MatchesKind(SymbolKind.Method, SymbolKind.Property));
                     }
                     else
                     {
@@ -234,8 +237,6 @@ private static bool IsRenameValid(ConflictResolution conflictResolution, ISymbol
                 // Some types of symbols (namespaces, cref stuff, etc) might not have ContainingAssemblies
                 if (renamedSymbol.ContainingAssembly != null)
                 {
-                    var project = conflictResolution.NewSolution.GetProject(renamedSymbol.ContainingAssembly, cancellationToken);
-
                     // There also might be language specific rules we need to include
                     var languageRenameService = project.LanguageServices.GetService<IRenameRewriterLanguageService>();
                     var languageConflicts = await languageRenameService.ComputeDeclarationConflictsAsync(

src/Workspaces/Core/Portable/Rename/ConflictEngine/DeclarationConflictHelpers.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -17,31 +18,8 @@ public static ImmutableArray<Location> GetMembersWithConflictingSignatures(IMeth
                                             .OfType<IMethodSymbol>()
                                             .Where(m => !m.Equals(renamedMethod) && m.Arity == renamedMethod.Arity);
 
-            var signatureToConflictingMember = new Dictionary<ImmutableArray<ITypeSymbol>, IMethodSymbol>(ConflictingSignatureComparer.Instance);
-
-            foreach (var method in potentiallyConfictingMethods)
-            {
-                foreach (var signature in GetAllSignatures(method, trimOptionalParameters))
-                {
-                    signatureToConflictingMember[signature] = method;
-                }
-            }
-
-            var builder = ArrayBuilder<Location>.GetInstance();
-
-            foreach (var signature in GetAllSignatures(renamedMethod, trimOptionalParameters))
-            {
-                if (signatureToConflictingMember.TryGetValue(signature, out var conflictingSymbol))
-                {
-                    if (!(conflictingSymbol.PartialDefinitionPart != null && conflictingSymbol.PartialDefinitionPart == renamedMethod) &&
-                        !(conflictingSymbol.PartialImplementationPart != null && conflictingSymbol.PartialImplementationPart == renamedMethod))
-                    {
-                        builder.AddRange(conflictingSymbol.Locations);
-                    }
-                }
-            }
-
-            return builder.ToImmutableAndFree();
+            return GetConflictLocations(renamedMethod, potentiallyConfictingMethods,
+                (method) => GetAllSignatures((method as IMethodSymbol).Parameters, trimOptionalParameters));
         }
 
         public static ImmutableArray<Location> GetMembersWithConflictingSignatures(IPropertySymbol renamedProperty, bool trimOptionalParameters)
@@ -51,19 +29,27 @@ public static ImmutableArray<Location> GetMembersWithConflictingSignatures(IProp
                                             .OfType<IPropertySymbol>()
                                             .Where(m => !m.Equals(renamedProperty) && m.Parameters.Count() == renamedProperty.Parameters.Count());
 
-            var signatureToConflictingMember = new Dictionary<ImmutableArray<ITypeSymbol>, IPropertySymbol>(ConflictingSignatureComparer.Instance);
+            return GetConflictLocations(renamedProperty, potentiallyConfictingProperties, 
+                (property)=>GetAllSignatures((property as IPropertySymbol).Parameters, trimOptionalParameters));
+        }
+
+        private static ImmutableArray<Location> GetConflictLocations(ISymbol renamedMember, 
+            IEnumerable<ISymbol> potentiallyConfictingMembers,
+            Func<ISymbol, ImmutableArray<ImmutableArray<ITypeSymbol>>> getAllSignatures)
+        {
+            var signatureToConflictingMember = new Dictionary<ImmutableArray<ITypeSymbol>, ISymbol>(ConflictingSignatureComparer.Instance);
 
-            foreach (var property in potentiallyConfictingProperties)
+            foreach (var member in potentiallyConfictingMembers)
             {
-                foreach (var signature in GetAllSignatures(property, trimOptionalParameters))
+                foreach (var signature in getAllSignatures(member))
                 {
-                    signatureToConflictingMember[signature] = property;
+                    signatureToConflictingMember[signature] = member;
                 }
             }
 
             var builder = ArrayBuilder<Location>.GetInstance();
 
-            foreach (var signature in GetAllSignatures(renamedProperty, trimOptionalParameters))
+            foreach (var signature in getAllSignatures(renamedMember))
             {
                 if (signatureToConflictingMember.TryGetValue(signature, out var conflictingSymbol))
                 {
@@ -94,41 +80,13 @@ public int GetHashCode(ImmutableArray<ITypeSymbol> obj)
             }
         }
 
-        private static ImmutableArray<ImmutableArray<ITypeSymbol>> GetAllSignatures(IMethodSymbol method, bool trimOptionalParameters)
-        {
-            var resultBuilder = ArrayBuilder<ImmutableArray<ITypeSymbol>>.GetInstance();
-
-            var signatureBuilder = ArrayBuilder<ITypeSymbol>.GetInstance();
-
-            if (method.MethodKind == MethodKind.Conversion)
-            {
-                signatureBuilder.Add(method.ReturnType);
-            }
-
-            foreach (var parameter in method.Parameters)
-            {
-                // In VB, a method effectively creates multiple signatures which are produced by
-                // chopping off each of the optional parameters on the end, last to first, per 4.1.1 of
-                // the spec.
-                if (trimOptionalParameters && parameter.IsOptional)
-                {
-                    resultBuilder.Add(signatureBuilder.ToImmutable());
-                }
-
-                signatureBuilder.Add(parameter.Type);
-            }
-
-            resultBuilder.Add(signatureBuilder.ToImmutableAndFree());
-            return resultBuilder.ToImmutableAndFree();
-        }
-
-        private static ImmutableArray<ImmutableArray<ITypeSymbol>> GetAllSignatures(IPropertySymbol property, bool trimOptionalParameters)
+        private static ImmutableArray<ImmutableArray<ITypeSymbol>> GetAllSignatures(ImmutableArray<IParameterSymbol> parameters, bool trimOptionalParameters)
         {
             var resultBuilder = ArrayBuilder<ImmutableArray<ITypeSymbol>>.GetInstance();
 
             var signatureBuilder = ArrayBuilder<ITypeSymbol>.GetInstance();
 
-            foreach (var parameter in property.Parameters)
+            foreach (var parameter in parameters)
             {
                 // In VB, a method effectively creates multiple signatures which are produced by
                 // chopping off each of the optional parameters on the end, last to first, per 4.1.1 of