|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.UseInferredMemberName;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using Xunit.Abstractions;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.InferredMemberName;
[Trait(Traits.Feature, Traits.Features.CodeActionsUseInferredMemberName)]
public class UseInferredMemberNameTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor
{
public UseInferredMemberNameTests(ITestOutputHelper logger)
: base(logger)
{
}
internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
=> (new CSharpUseInferredMemberNameDiagnosticAnalyzer(), new CSharpUseInferredMemberNameCodeFixProvider());
private static readonly CSharpParseOptions s_parseOptions =
CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.Latest);
[Fact]
public async Task TestInferredTupleName()
{
await TestAsync(
"""
class C
{
void M()
{
int a = 1;
var t = ([||]a: a, 2);
}
}
""",
"""
class C
{
void M()
{
int a = 1;
var t = (a, 2);
}
}
""", parseOptions: s_parseOptions);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24480")]
public async Task TestInferredTupleName_WithAmbiguity()
{
await TestMissingAsync(
"""
class C
{
void M()
{
int alice = 1;
(int, int, string) t = ([||]alice: alice, alice, null);
}
}
""", parameters: new TestParameters(parseOptions: s_parseOptions));
}
[Fact]
public async Task TestInferredTupleNameAfterCommaWithCSharp6()
{
await TestActionCountAsync(
"""
class C
{
void M()
{
int a = 2;
var t = (1, [||]a: a);
}
}
""", count: 0, parameters: new TestParameters(CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)));
}
[Fact]
public async Task TestInferredTupleNameAfterCommaWithCSharp7()
{
await TestActionCountAsync(
"""
class C
{
void M()
{
int a = 2;
var t = (1, [||]a: a);
}
}
""", count: 0, parameters: new TestParameters(CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7)));
}
[Fact]
public async Task TestFixAllInferredTupleNameWithTrivia()
{
await TestAsync(
"""
class C
{
void M()
{
int a = 1;
int b = 2;
var t = ( /*before*/ {|FixAllInDocument:a:|} /*middle*/ a /*after*/, /*before*/ b: /*middle*/ b /*after*/);
}
}
""",
"""
class C
{
void M()
{
int a = 1;
int b = 2;
var t = ( /*before*/ /*middle*/ a /*after*/, /*before*/ /*middle*/ b /*after*/);
}
}
""", parseOptions: s_parseOptions);
}
[Fact]
public async Task TestInferredAnonymousTypeMemberName()
{
await TestAsync(
"""
class C
{
void M()
{
int a = 1;
var t = new { [||]a= a, 2 };
}
}
""",
"""
class C
{
void M()
{
int a = 1;
var t = new { a, 2 };
}
}
""", parseOptions: s_parseOptions);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/24480")]
public async Task TestInferredAnonymousTypeMemberName_WithAmbiguity()
{
await TestMissingAsync(
"""
class C
{
void M()
{
int alice = 1;
var t = new { [||]alice=alice, alice };
}
}
""", parameters: new TestParameters(parseOptions: s_parseOptions));
}
[Fact]
public async Task TestFixAllInferredAnonymousTypeMemberNameWithTrivia()
{
await TestAsync(
"""
class C
{
void M()
{
int a = 1;
int b = 2;
var t = new { /*before*/ {|FixAllInDocument:a =|} /*middle*/ a /*after*/, /*before*/ b = /*middle*/ b /*after*/ };
}
}
""",
"""
class C
{
void M()
{
int a = 1;
int b = 2;
var t = new { /*before*/ /*middle*/ a /*after*/, /*before*/ /*middle*/ b /*after*/ };
}
}
""", parseOptions: s_parseOptions);
}
}
|