Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -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;

/// <summary>
/// [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]
/// </summary>
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,
"<Project Sdk=\"Microsoft.NET.Sdk\"><PropertyGroup><TargetFramework>net10.0</TargetFramework><OutputType>Library</OutputType></PropertyGroup></Project>"
)
.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);
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -245,30 +245,72 @@ CancellationToken ct
return root is null || model is null ? [] : ConversionCasts(root, model, method, ct);
}

/// <summary>
/// One edit per OUTERMOST converted expression. A conversion nested inside another
/// (<c>Twice(Pass(a))</c>) is cast inside the outer replacement, never as a second,
/// overlapping edit that <see cref="SourceText.WithChanges(TextChange[])"/> rejects.
/// </summary>
private static List<TextChange> ConversionCasts(
SyntaxNode root,
SemanticModel model,
IMethodSymbol method,
CancellationToken ct
)
{
var converted = root.DescendantNodes()
.OfType<ExpressionSyntax>()
.Where(expression => ConvertsThrough(model, expression, method, ct))
.ToList();
var nested = converted.ToHashSet();
return
[
.. root.DescendantNodes()
.OfType<ExpressionSyntax>()
.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})"
)),
];
}

/// <summary>True when <paramref name="expression"/> is converted through <paramref name="method"/>.</summary>
private static bool ConvertsThrough(
SemanticModel model,
ExpressionSyntax expression,
IMethodSymbol method,
CancellationToken ct
)
{
return SymbolEqualityComparer.Default.Equals(
model.GetConversion(expression, ct).MethodSymbol?.OriginalDefinition,
method.OriginalDefinition
);
}

/// <summary><c>(T)(expression)</c>, the target type spelled as it reads at <paramref name="at"/>.</summary>
private static string CastText(
SyntaxNode expression,
IMethodSymbol method,
SemanticModel model,
SyntaxNode at
)
{
return $"({method.ReturnType.ToMinimalDisplayString(model, at.SpanStart)})({expression})";
}

/// <summary>The edit, when the compiler finds no error the respelling introduced.</summary>
private static async Task<RenameEditResult> VerifiedOperatorEditAsync(
Solution solution,
Expand Down
Loading