Smart Rename: Provide additional context for renamed symbol

src/EditorFeatures/CSharp/InlineRename/CSharpEditorInlineRenameService.cs

@@ -4,9 +4,20 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editor.Implementation.InlineRename;
+using Microsoft.CodeAnalysis.GoToDefinition;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.Options;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.InlineRename;
 
@@ -16,4 +27,108 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.InlineRename;
 internal sealed class CSharpEditorInlineRenameService([ImportMany] IEnumerable<IRefactorNotifyService> refactorNotifyServices)
     : AbstractEditorInlineRenameService(refactorNotifyServices)
 {
+    private const int NumberOfContextLines = 20;
+    private const int MaxDefinitionCount = 10;
+    private const int MaxReferenceCount = 50;
+
+    /// <summary>
+    /// Uses semantic information of renamed symbol to produce a map containing contextual information for use in Copilot rename feature
+    /// </summary>
+    /// <returns>Map where key indicates the kind of semantic information, and value is an array of relevant code snippets.</returns>
+    public override async Task<ImmutableDictionary<string, ImmutableArray<string>>> GetRenameContextAsync(
+        IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken)
+    {
+        using var _1 = PooledHashSet<TextSpan>.GetInstance(out var seen);
+        using var _2 = ArrayBuilder<string>.GetInstance(out var definitions);
+        using var _3 = ArrayBuilder<string>.GetInstance(out var references);
+        using var _4 = ArrayBuilder<string>.GetInstance(out var docComments);
+
+        foreach (var renameDefinition in inlineRenameInfo.DefinitionLocations.Take(MaxDefinitionCount))
+        {
+            // Find largest snippet of code that represents the definition
+            var containingStatementOrDeclarationSpan =
+                await TryGetSurroundingNodeSpanAsync<MemberDeclarationSyntax>(renameDefinition.Document, renameDefinition.SourceSpan, cancellationToken).ConfigureAwait(false) ??
+                await TryGetSurroundingNodeSpanAsync<StatementSyntax>(renameDefinition.Document, renameDefinition.SourceSpan, cancellationToken).ConfigureAwait(false);
+
+            // Find documentation comments of definitions
+            var symbolService = renameDefinition.Document.GetRequiredLanguageService<IGoToDefinitionSymbolService>();
+            if (symbolService is not null)
+            {
+                var textSpan = inlineRenameInfo.TriggerSpan;
+                var (symbol, _, _) = await symbolService.GetSymbolProjectAndBoundSpanAsync(
+                    renameDefinition.Document, textSpan.Start, cancellationToken)
+                    .ConfigureAwait(true);
+                var docComment = symbol?.GetDocumentationCommentXml(expandIncludes: true, cancellationToken: cancellationToken);
+                if (!string.IsNullOrWhiteSpace(docComment))
+                {
+                    docComments.Add(docComment!);
+                }
+            }
+
+            var documentText = await renameDefinition.Document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            AddSpanOfInterest(documentText, renameDefinition.SourceSpan, containingStatementOrDeclarationSpan, definitions);
+        }
+
+        foreach (var renameLocation in inlineRenameLocationSet.Locations.Take(MaxReferenceCount))
+        {
+            // Find largest snippet of code that represents the reference
+            var containingStatementOrDeclarationSpan =
+                await TryGetSurroundingNodeSpanAsync<MemberDeclarationSyntax>(renameLocation.Document, renameLocation.TextSpan, cancellationToken).ConfigureAwait(false) ??
+                await TryGetSurroundingNodeSpanAsync<BaseMethodDeclarationSyntax>(renameLocation.Document, renameLocation.TextSpan, cancellationToken).ConfigureAwait(false) ??
+                await TryGetSurroundingNodeSpanAsync<StatementSyntax>(renameLocation.Document, renameLocation.TextSpan, cancellationToken).ConfigureAwait(false);
+
+            var documentText = await renameLocation.Document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+            AddSpanOfInterest(documentText, renameLocation.TextSpan, containingStatementOrDeclarationSpan, references);
+        }
+
+        var contextBuilder = ImmutableDictionary.CreateBuilder<string, ImmutableArray<string>>();
+        if (!definitions.IsEmpty)
+        {
+            contextBuilder.Add("definition", definitions.ToImmutable());
+        }
+        if (!references.IsEmpty)
+        {
+            contextBuilder.Add("reference", references.ToImmutable());
+        }
+        if (!docComments.IsEmpty)
+        {
+            contextBuilder.Add("documentation", docComments.ToImmutable());
+        }
+
+        return contextBuilder.ToImmutableDictionary();
+
+        void AddSpanOfInterest(SourceText documentText, TextSpan fallbackSpan, TextSpan? surroundingSpanOfInterest, ArrayBuilder<string> resultBuilder)
+        {
+            int startPosition, endPosition, startLine = 0, endLine = 0, lineCount = 0;
+            if (surroundingSpanOfInterest is not null)
+            {
+                startPosition = surroundingSpanOfInterest.Value.Start;
+                endPosition = surroundingSpanOfInterest.Value.End;
+                startLine = documentText.Lines.GetLineFromPosition(surroundingSpanOfInterest.Value.Start).LineNumber;
+                endLine = documentText.Lines.GetLineFromPosition(surroundingSpanOfInterest.Value.End).LineNumber;
+                lineCount = endLine - startLine + 1;
+            }
+
+            // If a well defined surrounding span was not computed or if the computed surrounding span was too large,
+            // select a span that encompasses NumberOfContextLines lines above and NumberOfContextLines lines below the identifier.
+            if (surroundingSpanOfInterest is null || lineCount <= 0 || lineCount > NumberOfContextLines * 2)
+            {
+                startLine = Math.Max(0, documentText.Lines.GetLineFromPosition(fallbackSpan.Start).LineNumber - NumberOfContextLines);
+                endLine = Math.Min(documentText.Lines.Count - 1, documentText.Lines.GetLineFromPosition(fallbackSpan.End).LineNumber + NumberOfContextLines);
+            }
+
+            // If the start and end positions are not at the beginning and end of the start and end lines respectively,
+            // expand to select the corresponding lines completely.
+            startPosition = documentText.Lines[startLine].Start;
+            endPosition = documentText.Lines[endLine].End;
+            var length = endPosition - startPosition + 1;
+
+            surroundingSpanOfInterest = new TextSpan(startPosition, length);
+
+            if (seen.Add(surroundingSpanOfInterest.Value))
+            {
+                resultBuilder.Add(documentText.GetSubText(surroundingSpanOfInterest.Value).ToString());
+            }
+        }
+    }
 }

src/EditorFeatures/Core.Wpf/InlineRename/UI/SmartRename/SmartRenameViewModel.cs

@@ -3,21 +3,23 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Windows.Input;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.InlineRename;
 using Microsoft.CodeAnalysis.Editor.InlineRename;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.EditorFeatures.Lightup;
 using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
-using Microsoft.VisualStudio.PlatformUI;
 
 namespace Microsoft.CodeAnalysis.InlineRename.UI.SmartRename;
 
@@ -65,6 +67,11 @@ internal sealed partial class SmartRenameViewModel : INotifyPropertyChanged, IDi
     /// </summary>
     public bool IsAutomaticSuggestionsEnabled { get; private set; }
 
+    /// <summary>
+    /// Determines whether smart rename gets semantic context to augment the request for suggested names.
+    /// </summary>
+    public bool IsUsingSemanticContext { get; }
+
     private string? _selectedSuggestedName;
 
     /// <summary>
@@ -114,12 +121,13 @@ public SmartRenameViewModel(
         _smartRenameSession.PropertyChanged += SessionPropertyChanged;
 
         BaseViewModel = baseViewModel;
-        BaseViewModel.PropertyChanged += IdentifierTextPropertyChanged;
-        this.BaseViewModel.IdentifierText = baseViewModel.IdentifierText;
+        BaseViewModel.PropertyChanged += BaseViewModelPropertyChanged;
+        BaseViewModel.IdentifierText = baseViewModel.IdentifierText;
 
         SetupTelemetry();
 
         this.SupportsAutomaticSuggestions = _globalOptionService.GetOption(InlineRenameUIOptionsStorage.GetSuggestionsAutomatically);
+        this.IsUsingSemanticContext = _globalOptionService.GetOption(InlineRenameUIOptionsStorage.GetSuggestionsContext);
         // Use existing "CollapseSuggestionsPanel" option (true if user does not wish to get suggestions automatically) to honor user's choice.
         this.IsAutomaticSuggestionsEnabled = this.SupportsAutomaticSuggestions && !_globalOptionService.GetOption(InlineRenameUIOptionsStorage.CollapseSuggestionsPanel);
         if (this.IsAutomaticSuggestionsEnabled)
@@ -151,43 +159,65 @@ private async Task GetSuggestionsTaskAsync(bool isAutomaticOnInitialization, Can
     {
         if (isAutomaticOnInitialization)
         {
-            // ConfigureAwait(true) to stay on the UI thread;
-            // WPF view is bound to _smartRenameSession properties and so they must be updated on the UI thread.
-            await Task.Delay(_smartRenameSession.AutomaticFetchDelay, cancellationToken).ConfigureAwait(true);
+            await Task.Delay(_smartRenameSession.AutomaticFetchDelay, cancellationToken)
+                .ConfigureAwait(false);
         }
 
         if (cancellationToken.IsCancellationRequested || _isDisposed)
         {
             return;
         }
-        _ = await _smartRenameSession.GetSuggestionsAsync(cancellationToken).ConfigureAwait(true);
-        return;
+
+        if (IsUsingSemanticContext)
+        {
+            var document = this.BaseViewModel.Session.TriggerDocument;
+            var smartRenameContext = ImmutableDictionary<string, string[]>.Empty;
+            var editorRenameService = document.GetRequiredLanguageService<IEditorInlineRenameService>();
+            var renameLocations = await this.BaseViewModel.Session.AllRenameLocationsTask.JoinAsync(cancellationToken)
+                .ConfigureAwait(false);
+            var context = await editorRenameService.GetRenameContextAsync(this.BaseViewModel.Session.RenameInfo, renameLocations, cancellationToken)
+                .ConfigureAwait(false);
+            smartRenameContext = ImmutableDictionary.CreateRange<string, string[]>(
+                context
+                .Select(n => new KeyValuePair<string, string[]>(n.Key, n.Value.ToArray())));
+            _ = await _smartRenameSession.GetSuggestionsAsync(smartRenameContext, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        else
+        {
+            _ = await _smartRenameSession.GetSuggestionsAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
     }
 
     private void SessionPropertyChanged(object sender, PropertyChangedEventArgs e)
     {
-        _threadingContext.ThrowIfNotOnUIThread();
-        // _smartRenameSession.SuggestedNames is a normal list. We need to convert it to ObservableCollection to bind to UI Element.
-        if (e.PropertyName == nameof(_smartRenameSession.SuggestedNames))
+        _ = _threadingContext.JoinableTaskFactory.RunAsync(async () =>
         {
-            var textInputBackup = BaseViewModel.IdentifierText;
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
 
-            SuggestedNames.Clear();
-            // Set limit of 3 results
-            foreach (var name in _smartRenameSession.SuggestedNames.Take(3))
+            // _smartRenameSession.SuggestedNames is a normal list. We need to convert it to ObservableCollection to bind to UI Element.
+            if (e.PropertyName == nameof(_smartRenameSession.SuggestedNames))
             {
-                SuggestedNames.Add(name);
-            }
+                var textInputBackup = BaseViewModel.IdentifierText;
 
-            // Changing the list may have changed the text in the text box. We need to restore it.
-            BaseViewModel.IdentifierText = textInputBackup;
+                SuggestedNames.Clear();
+                // Set limit of 3 results
+                foreach (var name in _smartRenameSession.SuggestedNames.Take(3))
+                {
+                    SuggestedNames.Add(name);
+                }
 
-            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSuggestionsPanelExpanded)));
-            return;
-        }
+                // Changing the list may have changed the text in the text box. We need to restore it.
+                BaseViewModel.IdentifierText = textInputBackup;
+
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSuggestionsPanelExpanded)));
+                return;
+            }
 
-        // For the rest of the property, like HasSuggestions, IsAvailable and etc. Just forward it has changed to subscriber
-        PropertyChanged?.Invoke(this, e);
+            // For the rest of the property, like HasSuggestions, IsAvailable and etc. Just forward it has changed to subscriber
+            PropertyChanged?.Invoke(this, e);
+        });
     }
 
     public string? ScrollSuggestions(string currentIdentifier, bool down)
@@ -226,7 +256,7 @@ public void Dispose()
     {
         _isDisposed = true;
         _smartRenameSession.PropertyChanged -= SessionPropertyChanged;
-        BaseViewModel.PropertyChanged -= IdentifierTextPropertyChanged;
+        BaseViewModel.PropertyChanged -= BaseViewModelPropertyChanged;
         _smartRenameSession.Dispose();
         _cancellationTokenSource?.Cancel();
         _cancellationTokenSource?.Dispose();
@@ -260,7 +290,7 @@ public void ToggleOrTriggerSuggestions()
     private void NotifyPropertyChanged([CallerMemberName] string? name = null)
             => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
 
-    private void IdentifierTextPropertyChanged(object sender, PropertyChangedEventArgs e)
+    private void BaseViewModelPropertyChanged(object sender, PropertyChangedEventArgs e)
     {
         if (e.PropertyName == nameof(BaseViewModel.IdentifierText))
         {

src/EditorFeatures/Core.Wpf/Lightup/ISmartRenameSessionWrapper.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
@@ -29,6 +30,7 @@ namespace Microsoft.CodeAnalysis.EditorFeatures.Lightup;
     private static readonly Func<object, IReadOnlyList<string>> s_suggestedNamesAccessor;
 
     private static readonly Func<object, CancellationToken, Task<IReadOnlyList<string>>> s_getSuggestionsAsync;
+    private static readonly Func<object, ImmutableDictionary<string, string[]>, CancellationToken, Task<IReadOnlyList<string>>> s_getSuggestionsAsync_WithContext;
     private static readonly Action<object> s_onCancel;
     private static readonly Action<object, string> s_onSuccess;
 
@@ -47,13 +49,14 @@ static ISmartRenameSessionWrapper()
         s_suggestedNamesAccessor = LightupHelpers.CreatePropertyAccessor<object, IReadOnlyList<string>>(s_wrappedType, nameof(SuggestedNames), []);
 
         s_getSuggestionsAsync = LightupHelpers.CreateFunctionAccessor<object, CancellationToken, Task<IReadOnlyList<string>>>(s_wrappedType, nameof(GetSuggestionsAsync), typeof(CancellationToken), SpecializedTasks.EmptyReadOnlyList<string>());
+        s_getSuggestionsAsync_WithContext = LightupHelpers.CreateFunctionAccessor<object, ImmutableDictionary<string, string[]>, CancellationToken, Task<IReadOnlyList<string>>>(s_wrappedType, nameof(GetSuggestionsAsync), typeof(ImmutableDictionary<string, string[]>), typeof(CancellationToken), SpecializedTasks.EmptyReadOnlyList<string>());
         s_onCancel = LightupHelpers.CreateActionAccessor<object>(s_wrappedType, nameof(OnCancel));
         s_onSuccess = LightupHelpers.CreateActionAccessor<object, string>(s_wrappedType, nameof(OnSuccess), typeof(string));
     }
 
     private ISmartRenameSessionWrapper(object instance)
     {
-        this._instance = instance;
+        _instance = instance;
     }
 
     public TimeSpan AutomaticFetchDelay => s_automaticFetchDelayAccessor(_instance);
@@ -93,6 +96,9 @@ public static bool IsInstance([NotNullWhen(true)] object? instance)
     public Task<IReadOnlyList<string>> GetSuggestionsAsync(CancellationToken cancellationToken)
         => s_getSuggestionsAsync(_instance, cancellationToken);
 
+    public Task<IReadOnlyList<string>> GetSuggestionsAsync(ImmutableDictionary<string, string[]> context, CancellationToken cancellationToken)
+        => s_getSuggestionsAsync_WithContext(_instance, context, cancellationToken);
+
     public void OnCancel()
         => s_onCancel(_instance);