From 140a544da3c3f9ccaeb67ca49106a6194d36cade Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Fri, 20 Nov 2026 00:52:09 +1100 Subject: [PATCH 1/2] Failing test: renaming an implicit conversion explicit fails with 'The changes must not overlap' when one converted use is nested inside another (Twice(Pass(a))) --- ...kspaceManagerRenameConversionCastsTests.cs | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerRenameConversionCastsTests.cs diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerRenameConversionCastsTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerRenameConversionCastsTests.cs new file mode 100644 index 00000000..3b477380 --- /dev/null +++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerRenameConversionCastsTests.cs @@ -0,0 +1,90 @@ +using Microsoft.CodeAnalysis.Text; +using SharpLsp.Sidecar.Common; +using SharpLsp.Sidecar.CSharp.Workspace; + +#pragma warning disable CA1515 // Types can be internal +#pragma warning disable RS1035 // File IO is banned for analyzers — these are tests + +namespace SharpLsp.Sidecar.CSharp.Tests; + +/// +/// [RENAME-COVERAGE] Turning an implicit conversion explicit casts only the uses that were +/// implicit: a cast already written stays one cast, and a conversion nested inside another +/// converted argument gets its own cast without the two edits overlapping. [RENAME-ERRORS] +/// +public sealed class WorkspaceManagerRenameConversionCastsTests : IAsyncLifetime, IDisposable +{ + private const string Source = """ + namespace Casts; + + public readonly struct Money + { + public Money(int cents) => Cents = cents; + public int Cents { get; } + public static implicit operator int(Money value) => value.Cents; + } + + public static class Uses + { + public static int Spelled(Money a) => (int)a; + public static Money Pass(int cents) => new(cents); + public static int Twice(int cents) => cents * 2; + public static int Nested(Money a) => Twice(Pass(a)); + } + + """; + + private readonly string _root = NativePaths.Temp($"sharplsp-rename-casts-{Guid.NewGuid():N}"); + private readonly WorkspaceManager _manager = new(); + private string SourcePath => NativePaths.Join(_root, "Money.cs"); + + public async Task InitializeAsync() + { + _ = Directory.CreateDirectory(_root); + var project = NativePaths.Join(_root, "Casts.csproj"); + await File.WriteAllTextAsync( + project, + "net10.0Library" + ) + .ConfigureAwait(false); + await File.WriteAllTextAsync(SourcePath, Source).ConfigureAwait(false); +#pragma warning disable CS0618 // Obsolete OpenAsync placeholder + var opened = await _manager.OpenAsync(project).ConfigureAwait(false); +#pragma warning restore CS0618 + Assert.False(opened.IsError, opened.Match(_ => "ok", error => error)); + } + + public Task DisposeAsync() + { + Dispose(); + return Task.CompletedTask; + } + + public void Dispose() + { + _manager.Dispose(); + if (Directory.Exists(_root)) + { + Directory.Delete(_root, true); + } + } + + [Fact] + public async Task Implicit_to_explicit_casts_a_conversion_nested_in_a_converted_argument_without_overlapping_edits() + { + const string marker = "implicit operator int"; + var offset = Source.IndexOf(marker, StringComparison.Ordinal); + var at = SourceText.From(Source).Lines.GetLinePosition(offset); + + var result = await _manager.RenameAsync(SourcePath, at.Line, at.Character, "explicit"); + + Assert.False(result.IsError, result.Match(_ => "ok", error => error)); + var edits = (+result).DocumentChanges.SelectMany(change => change.Edits); + var renamed = TextEditing.ApplyEdits(Source, edits); + Assert.Contains("explicit operator int", renamed, StringComparison.Ordinal); + Assert.Contains("Spelled(Money a) => (int)a;", renamed, StringComparison.Ordinal); + Assert.DoesNotContain("(int)(int)", renamed, StringComparison.Ordinal); + Assert.DoesNotContain("(int)((int)", renamed, StringComparison.Ordinal); + Assert.Contains("Twice((int)(Pass((int)(a))))", renamed, StringComparison.Ordinal); + } +} From 4487f62d33475135e25aa66c00051a6913d1026c Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Fri, 20 Nov 2026 03:25:07 +1100 Subject: [PATCH 2/2] Renaming an implicit conversion explicit casts nested conversions inside the outer cast, built from the syntax tree, instead of emitting overlapping edits that fail the whole rename --- .../WorkspaceManager.Rename.Operators.cs | 62 ++++++++++++++++--- 1 file changed, 52 insertions(+), 10 deletions(-) diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.Operators.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.Operators.cs index ca52306a..dfda0b3d 100644 --- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.Operators.cs +++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/WorkspaceManager.Rename.Operators.cs @@ -245,6 +245,11 @@ CancellationToken ct return root is null || model is null ? [] : ConversionCasts(root, model, method, ct); } + /// + /// One edit per OUTERMOST converted expression. A conversion nested inside another + /// (Twice(Pass(a))) is cast inside the outer replacement, never as a second, + /// overlapping edit that rejects. + /// private static List ConversionCasts( SyntaxNode root, SemanticModel model, @@ -252,23 +257,60 @@ private static List ConversionCasts( CancellationToken ct ) { + var converted = root.DescendantNodes() + .OfType() + .Where(expression => ConvertsThrough(model, expression, method, ct)) + .ToList(); + var nested = converted.ToHashSet(); return [ - .. root.DescendantNodes() - .OfType() - .Where(expression => - SymbolEqualityComparer.Default.Equals( - model.GetConversion(expression, ct).MethodSymbol?.OriginalDefinition, - method.OriginalDefinition + .. converted + .Where(expression => !expression.Ancestors().Any(nested.Contains)) + .Select(outer => new TextChange( + outer.Span, + CastText( + outer.ReplaceNodes( + converted.Where(inner => + inner != outer && outer.Span.Contains(inner.Span) + ), + (_, rewritten) => + SyntaxFactory.ParseExpression( + CastText(rewritten, method, model, outer) + ) + ), + method, + model, + outer ) - ) - .Select(expression => new TextChange( - expression.Span, - $"({method.ReturnType.ToMinimalDisplayString(model, expression.SpanStart)})({expression})" )), ]; } + /// True when is converted through . + private static bool ConvertsThrough( + SemanticModel model, + ExpressionSyntax expression, + IMethodSymbol method, + CancellationToken ct + ) + { + return SymbolEqualityComparer.Default.Equals( + model.GetConversion(expression, ct).MethodSymbol?.OriginalDefinition, + method.OriginalDefinition + ); + } + + /// (T)(expression), the target type spelled as it reads at . + private static string CastText( + SyntaxNode expression, + IMethodSymbol method, + SemanticModel model, + SyntaxNode at + ) + { + return $"({method.ReturnType.ToMinimalDisplayString(model, at.SpanStart)})({expression})"; + } + /// The edit, when the compiler finds no error the respelling introduced. private static async Task VerifiedOperatorEditAsync( Solution solution,