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);
+ }
+}
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,