How to rename multiple symbols?

[Denis535]

It's looking very easy but I've not found the solution (:
I've found only one stackoverflow question Rename multiple symbols at once? (using Roslyn).

I've tried the next ways:

var solution = Project.Solution;

var compilation = await solution.Projects.First().GetCompilationAsync().ConfigureAwait( false );
var namespaceSymbol = compilation.GetSymbolsWithName( "Namespace", SymbolFilter.Namespace ).Single();
var classSymbol = compilation.GetTypeByMetadataName( "Namespace.Class" );

// Way №1
solution = await Renamer.RenameSymbolAsync( solution, namespaceSymbol, "Namespace_2", solution.Options, default ).ConfigureAwait( false );
solution = await Renamer.RenameSymbolAsync( solution, classSymbol, "Class_2", solution.Options, default ).ConfigureAwait( false ); // InvalidOperationException : Operation is not valid due to the current state of the object.

// Way №2
var editor = SymbolEditor.Create( solution );

var symbol1 = await editor.EditAllDeclarationsAsync( namespaceSymbol, (editor2, node, cancellationToken) => {
    editor2.SetName( node, "Namespace_2" );
    return Task.CompletedTask;
}, default ).ConfigureAwait( false );

var symbol2 = await editor.EditAllDeclarationsAsync( classSymbol, (editor2, node, cancellationToken) => {
    editor2.SetName( node, "Class_2" );
    return Task.CompletedTask;
}, default ).ConfigureAwait( false ); // ArgumentException : Can not find symbol "Class" in solution.

But both ways throw exception when child node (Class) is renamed after parent node (Namespace).
How can I achieve this? Should I sort symbols in order of depth? Or should I use node tracking here? Or something else?

[CyrusNajmabadi]

You'll likely need to acquire 'classSymbol' after the first rename has happened. Solutions/compilations/symbols are all snapshots and aren't going to be valid against a different Solution snapshot.

[Denis535]

@CyrusNajmabadi

I'm making CodeRefactoringProvider. I'm getting all symbols within span and then renaming them.
So, I don't like idea: "to acquire 'classSymbol' after the first rename has happened" because span will be invalid in changed document. Or I don't understand something?
Is there another way?

[ExportCodeRefactoringProvider( LanguageNames.CSharp, Name = nameof( ExampleCodeRefactoringProvider ) ), Shared]
public class ExampleCodeRefactoringProvider : CodeRefactoringProvider {

    public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) {
        var root = await context.Document.GetSyntaxRootAsync( context.CancellationToken ).ConfigureAwait( false );
        var model = await context.Document.GetSemanticModelAsync( context.CancellationToken ).ConfigureAwait( false );
        var symbols = GetSymbols( root, model, context.Span, context.CancellationToken ).Where( CanBeRenamed ).ToArray();

        if (symbols.Any()) {
            RegisterRefactoring( context, $"Make symbols '{symbols.Select( i => i.Name ).Join()}' start/end with underscore ({GetType().Name})", Action );
        }

        async Task<Solution> Action(CancellationToken cancellationToken) {
            var solution = context.Document.Project.Solution;
            foreach (var symbol in symbols) {
                solution = await WithFormattedSymbol( solution, symbol, "_{0}_", cancellationToken ).ConfigureAwait( false );
            }
            return solution;
        }
    }


    // Helpers/CodeRefactoringContext
    private static void RegisterRefactoring(CodeRefactoringContext context, string title, Func<CancellationToken, Task<Solution>> action) {
        context.RegisterRefactoring( CodeAction.Create( title, action, title ) );
    }
    // Helpers/Solution
    private static async Task<Solution> WithFormattedSymbol(Solution solution, ISymbol symbol, string format, CancellationToken cancellationToken) {
        var newName = string.Format( format, symbol.Name );
        return await Renamer.RenameSymbolAsync( solution, symbol, newName, solution.Options, cancellationToken ).ConfigureAwait( false );
    }
    // Helpers/Document
    private static IEnumerable<ISymbol> GetSymbols(SyntaxNode root, SemanticModel model, TextSpan span, CancellationToken cancellationToken) {
        // Note: GetDeclaredSymbol() returns symbol for MemberDeclarationSyntax nodes
        // Note: GetSymbolInfo() returns symbol for other nodes (IdentifierNameSyntax for example)
        foreach (var node in root.DescendantTokens( span ).Select( i => i.Parent ).Distinct()) {
            var symbol = model.GetDeclaredSymbol( node, cancellationToken ) ?? model.GetSymbolInfo( node, cancellationToken ).Symbol;
            if (symbol != null) yield return symbol;
        }
    }
    // Helpers/Symbol
    private static bool CanBeRenamed(ISymbol symbol) {
        return symbol.CanBeReferencedByName && !symbol.IsImplicitlyDeclared && symbol.Locations.First().IsInSource;
    }

}

[Denis535]

I think the question is: how to keep valid symbols in changed document.

[CyrusNajmabadi]

Is there another way?

The alternate way is to make each rename independently against the original solution. Then determine the changes that were made (there's a helper for this), and then merge all the changes to end up with one total change to make to the solution to get to the end result.

This is similar to how batch fixing works. We just try to run all the fixes against the original solution. And we attempt to merge the changes.

[Denis535]

there's a helper for this

Do you mean Solution.GetChanges?

var originalSolution = context.Document.Project.Solution;
var changes = new List<SolutionChanges>();
foreach (var symbol in symbols) {
    var newSolution = await WithFormattedSymbol( originalSolution, symbol, "_{0}_", cancellationToken ).ConfigureAwait( false );
    changes.Add( newSolution.GetChanges( originalSolution ) );
}

Okey, now I have list of SolutionChanges. But as I understand there is no public API to merge it?

[CyrusNajmabadi]

Do you mean Solution.GetChanges

Yes.

Okey, now I have list of SolutionChanges. But as I understand there is no public API to merge it?

Likely not. Similar to how git merging, you'll have to figure out how you want to deal with things if there are edits to the same content.

[Denis535]

Damn! there should be an easier way?!
Node tracking is made for something like this case. Only I can't figure out how to use it.

[CyrusNajmabadi]

you could annotate all your nodes of interest. Then rename one at a time. After the rename, look for the next annotated node to rename, and rinse/repeat until you're all done.

However. Doing N renames, 1 at a tiem in serial will be much much much much slower than doing N renames in parallel against the original solution and merging the results.

This will be true for several reasons.

1. Just being able to do the work in parallel means you'll be able to scale up to as many cores as you have.
2. Every time you fork a solution, (almost) all semantic information must be recomputed. So every rename done serially means doing all the semantic work over again. HOwever, if you apply N renames to the original solution, then all the semantics can be shared.
3. the 'Rename' operation depends on the 'Find References' operation, which itself depends on many indices that have been built against the solution. If you do this serially, then those operations will be slower as the indices muts be rebuilt for the portions of the Solution that have changed. Doing it in parallel means all the indices are built once and can be used for all the renames.

For all these reasons it is strongly recommended to do all the renames independently, and then merge the results.

[CyrusNajmabadi]

Also, just as an FYI, thse discussions may be better suited to discord.gg/csharp (#roslyn channel).

[Denis535]

This is not searchable and really hell for non-native english readers.
I have to figure out how to sort symbols in child-parent order. Is there a way to known child-parent relationship between symbols?

[CyrusNajmabadi]

I don't really know what you mean by 'child-parent order'

[Denis535]

NamespaceDeclaration is parent symbol for ClassDeclaration. ClassDeclaration is parent for FieldDeclaration. And and so on.
Precisely speaking, I should determine which symbols are independent from other. For example: ClassDeclaration depends on NamespaceDeclaration. So, I should rename ClassDeclaration first.

[CyrusNajmabadi]

As mentioned, renaming in any sort of order will likely be super slow.

If you do have to do this, there's no concept for this currently. You'd have to figure out whatever order you were trying to impose and then she and walk things in that order.

[Denis535]

Ahaha, DescendantTokens returns nodes in parent-child order, so I just need to use Reverse function to get child-parent order.

    var symbols = GetSymbols( root, model, context.Span, context.CancellationToken ).Where( CanBeRenamed ).Reverse().ToArray();

    private static IEnumerable<ISymbol> GetSymbols(SyntaxNode root, SemanticModel model, TextSpan span, CancellationToken cancellationToken) {
        // Note: GetDeclaredSymbol() returns symbol for MemberDeclarationSyntax nodes
        // Note: GetSymbolInfo() returns symbol for other nodes (IdentifierNameSyntax for example)
        var symbols = new HashSet<ISymbol>( SymbolEqualityComparer.Default );
        foreach (var node in root.DescendantTokens( span ).Select( i => i.Parent )) {
            var symbol = model.GetDeclaredSymbol( node, cancellationToken ) ?? model.GetSymbolInfo( node, cancellationToken ).Symbol;
            if (symbol != null && !symbols.Contains( symbol )) {
                symbols.Add( symbol );
                yield return symbol;
            }
        }
    }

    private static bool CanBeRenamed(ISymbol symbol) {
        return symbol.CanBeReferencedByName && !symbol.IsImplicitlyDeclared && symbol.Locations.First().IsInSource;
    }

@CyrusNajmabadi
#50147 (reply in thread)
Write your own merge function is not very simple task. Why Roslyn hasn't public API for it? Hope this will change one day.

P.S. Unfortunately, discussions are not very comfortable. Answers and replies are very similar in style.

[Denis535]

Symbols are treated as different !!! Maybe bug in SymbolEqualityComparer.Default.

        var symbols = new List<ISymbol>();
        foreach (var node in root!.DescendantNodesAndSelf()) {
            var symbol = model!.GetDeclaredSymbol( node, default );
            if (symbol != null && symbol.Name == "Func") {
                symbols.Add( symbol );
            }
        }

        foreach (var symbol in symbols.Distinct( SymbolEqualityComparer.Default )) {
            TestContext.WriteLine( symbol.Name );
        }

It will work right for: symbol.Name == "Class"

[CyrusNajmabadi]

I don't know what you're asking. Please provide repros so I can see what behavior you're observing and can potentially investigate.

Also, please consider using discord/gitter for this. It will allow you to get access to many more sources of assistance, not just me :-)

[Denis535]

Okey, Method definition and method implementation have different symbols. I think this is a bad decision, but apparently there were reasons for this.

It looks like even discord is better than discussions)

[CyrusNajmabadi]

It looks like even discord is better than discussions

Yup :-)

[CyrusNajmabadi]

I think this is a bad decision, but apparently there were reasons for this.

They are distinct entities with different purposes. They are spec'ed that way in the language (unlike partial types). You could imagine it like abstract/override (except we picked the same keyword here for both the def and impl). Conceptually, they are distinct.