Skip to content

R
roslyn

lwm1986 / roslyn
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
R
roslyn

体验新版 GitCode，发现更多精彩内容 >>

提交 735cbe97 编写于 作者: C CyrusNajmabadi
浏览文件
操作

Disable 'Populate Switch' in master. We'll be shipping this out of Future instead.

上级 17cf310d
隐藏空白更改
内联 并排
Showing with 0 addition and 2767 deletion
src/EditorFeatures/CSharpTest/CSharpEditorServicesTest.csproj
浏览文件 @ 735cbe97
......@@ -332,8 +332,6 @@
<Compile Include="Outlining\RegionDirectiveOutlinerTests.cs" />
<Compile Include="Outlining\SimpleLambdaExpressionOutlinerTests.cs" />
<Compile Include="Outlining\TypeDeclarationOutlinerTests.cs" />
<Compile Include="PopulateSwitch\PopulateSwitchTests.cs" />
<Compile Include="PopulateSwitch\PopulateSwitchTests_FixAllTests.cs" />
<Compile Include="QuickInfo\SemanticQuickInfoSourceTests.cs" />
<Compile Include="QuickInfo\SyntacticQuickInfoSourceTests.cs" />
<Compile Include="Semantics\SpeculationAnalyzerTests.cs" />
......
src/EditorFeatures/CSharpTest/PopulateSwitch/PopulateSwitchTests.cs 已删除 100644 → 0
浏览文件 @ 17cf310d
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp.CodeFixes.PopulateSwitch;
using Microsoft.CodeAnalysis.CSharp.Diagnostics.PopulateSwitch;
using Microsoft.CodeAnalysis.Diagnostics;
using Roslyn.Test.Utilities;
using System;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.PopulateSwitch
{
public partial class PopulateSwitchTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
{
internal override Tuple<DiagnosticAnalyzer, CodeFixProvider> CreateDiagnosticProviderAndFixer(Workspace workspace)
{
return new Tuple<DiagnosticAnalyzer, CodeFixProvider>(
new CSharpPopulateSwitchDiagnosticAnalyzer(), new CSharpPopulateSwitchCodeFixProvider());
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task AllMembersAndDefaultExist()
{
await TestMissingAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task AllMembersExist_NotDefault()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_NotDefault()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_WithDefault()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
default:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_NotDefault_EnumHasExplicitType()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum : long
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum : long
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_WithMembersAndDefaultInSection_NewValuesAboveDefaultSection()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.FizzBuzz:
break;
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_WithMembersAndDefaultInSection_AssumesDefaultIsInLastSection()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
default:
break;
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
default:
break;
case MyEnum.FizzBuzz:
break;
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NoMembersExist()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
}
}
}
}
",
@"
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
break;
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task UsingStaticEnum_AllMembersExist()
{
await TestMissingAsync(
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch ([|e|])
{
case CreateNew:
break;
case Create:
break;
case Open:
break;
case OpenOrCreate:
break;
case Truncate:
break;
case Append:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task UsingStaticEnum_AllMembersExist_OutOfDefaultOrder()
{
await TestMissingAsync(
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch ([|e|])
{
case CreateNew:
break;
case OpenOrCreate:
break;
case Truncate:
break;
case Open:
break;
case Append:
break;
case Create:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task UsingStaticEnum_MembersExist()
{
await TestAsync(
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch ([|e|])
{
case CreateNew:
break;
case Create:
break;
case Open:
break;
case OpenOrCreate:
break;
default:
break;
}
}
}
}
",
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch (e)
{
case CreateNew:
break;
case Create:
break;
case Open:
break;
case OpenOrCreate:
break;
case Truncate:
break;
case Append:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task UsingStaticEnum_NoMembersExist()
{
await TestAsync(
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch ([|e|])
{
}
}
}
}
",
@"
using static System.IO.FileMode;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = Append;
switch (e)
{
case CreateNew:
break;
case Create:
break;
case Open:
break;
case OpenOrCreate:
break;
case Truncate:
break;
case Append:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_EnumIsFlags()
{
await TestMissingAsync(
@"
using System;
namespace ConsoleApplication1
{
[Flags]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_EnumIsFlagsAttribute()
{
await TestMissingAsync(
@"
using System;
namespace ConsoleApplication1
{
[FlagsAttribute]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_EnumIsFullyQualifiedSystemFlags()
{
await TestMissingAsync(
@"
namespace ConsoleApplication1
{
[System.Flags]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_EnumIsFullyQualifiedSystemFlagsAttribute()
{
await TestMissingAsync(
@"
namespace ConsoleApplication1
{
[System.FlagsAttribute]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_NotDefault_EnumHasNonFlagsAttribute()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
[System.Obsolete]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
[System.Obsolete]
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_NotDefault_EnumIsNested()
{
await TestAsync(
@"
namespace ConsoleApplication1
{
class MyClass
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
void Method()
{
var e = MyEnum.Fizz;
switch ([|e|])
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
}
}
}
}
",
@"
namespace ConsoleApplication1
{
class MyClass
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
break;
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
");
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
public async Task NotAllMembersExist_SwitchIsNotEnum()
{
await TestMissingAsync(
@"
using System;
namespace ConsoleApplication1
{
class MyClass
{
void Method()
{
var e = ""test"";
switch ([|e|])
{
case ""test1"":
case ""test1"":
default:
break;
}
}
}
}
");
}
}
}
src/EditorFeatures/CSharpTest/PopulateSwitch/PopulateSwitchTests_FixAllTests.cs 已删除 100644 → 0
浏览文件 @ 17cf310d
using Roslyn.Test.Utilities;
using System.Threading.Tasks;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.PopulateSwitch
{
public partial class PopulateSwitchTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
{
[Fact]
[Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
[Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
public async Task TestFixAllInDocument()
{
var input = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum.Fizz;
switch ({|FixAllInDocument:e|})
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
class MyClass2
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
class MyClass3
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
var expected = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
default:
break;
}
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
class MyClass2
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
class MyClass3
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
await TestAsync(input, expected, compareTokens: false);
}
[Fact]
[Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
[Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
public async Task TestFixAllInProject()
{
var input = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum.Fizz;
switch ({|FixAllInProject:e|})
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
class MyClass2
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
class MyClass3
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
var expected = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
class MyClass2
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
class MyClass3
{
void Method()
{
var e = MyEnum.Fizz;
switch (e)
{
case MyEnum.Fizz:
case MyEnum.Buzz:
case MyEnum.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
await TestAsync(input, expected, compareTokens: false);
}
[Fact]
[Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)]
[Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
public async Task TestFixAllInSolution()
{
var input = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum1
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum1.Fizz;
switch ({|FixAllInSolution:e|})
{
case MyEnum1.Fizz:
case MyEnum1.Buzz:
case MyEnum1.FizzBuzz:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
enum MyEnum2
{
Fizz, Buzz, FizzBuzz
}
class MyClass2
{
void Method()
{
var e = MyEnum2.Fizz;
switch (e)
{
case MyEnum2.Fizz:
case MyEnum2.Buzz:
case MyEnum2.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication2
{
enum MyEnum3
{
Fizz, Buzz, FizzBuzz
}
class MyClass3
{
void Method()
{
var e = MyEnum3.Fizz;
switch (e)
{
case MyEnum3.Fizz:
case MyEnum3.Buzz:
case MyEnum3.FizzBuzz:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
var expected = @"
<Workspace>
<Project Language=""C#"" AssemblyName=""Assembly1"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication1
{
enum MyEnum1
{
Fizz, Buzz, FizzBuzz
}
class MyClass1
{
void Method()
{
var e = MyEnum1.Fizz;
switch (e)
{
case MyEnum1.Fizz:
case MyEnum1.Buzz:
case MyEnum1.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
<Document>
namespace ConsoleApplication1
{
enum MyEnum2
{
Fizz, Buzz, FizzBuzz
}
class MyClass2
{
void Method()
{
var e = MyEnum2.Fizz;
switch (e)
{
case MyEnum2.Fizz:
case MyEnum2.Buzz:
case MyEnum2.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
</Project>
<Project Language=""C#"" AssemblyName=""Assembly2"" CommonReferences=""true"">
<Document>
namespace ConsoleApplication2
{
enum MyEnum3
{
Fizz, Buzz, FizzBuzz
}
class MyClass3
{
void Method()
{
var e = MyEnum3.Fizz;
switch (e)
{
case MyEnum3.Fizz:
case MyEnum3.Buzz:
case MyEnum3.FizzBuzz:
break;
default:
break;
}
}
}
}
</Document>
</Project>
</Workspace>";
await TestAsync(input, expected, compareTokens: false);
}
}
}
src/EditorFeatures/VisualBasicTest/BasicEditorServicesTest.vbproj
浏览文件 @ 735cbe97
......@@ -329,8 +329,6 @@
<Compile Include="Outlining\RegionDirectiveOutlinerTests.vb" />
<Compile Include="Outlining\TypeDeclarationOutlinerTests.vb" />
<Compile Include="Outlining\XmlExpressionOutlinerTests.vb" />
<Compile Include="PopulateSwitch\PopulateSwitchTests.vb" />
<Compile Include="PopulateSwitch\PopulateSwitchTests_FixAllTests.vb" />
<Compile Include="QuickInfo\SemanticQuickInfoSourceTests.vb" />
<Compile Include="Recommendations\ArrayStatements\EraseKeywordRecommenderTests.vb" />
<Compile Include="Recommendations\ArrayStatements\PreserveKeywordRecommenderTests.vb" />
......
src/EditorFeatures/VisualBasicTest/PopulateSwitch/PopulateSwitchTests.vb 已删除 100644 → 0
浏览文件 @ 17cf310d
Imports Microsoft.CodeAnalysis.CodeFixes
Imports Microsoft.CodeAnalysis.Diagnostics
Imports Microsoft.CodeAnalysis.VisualBasic.CodeFixes.PopulateSwitch
Imports Microsoft.CodeAnalysis.VisualBasic.Diagnostics.PopulateSwitch
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.PopulateSwitch
Partial Public Class PopulateSwitchTests
Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest
Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As Tuple(Of DiagnosticAnalyzer, CodeFixProvider)
Return New Tuple(Of DiagnosticAnalyzer, CodeFixProvider)(New VisualBasicPopulateSwitchDiagnosticAnalyzer(), New VisualBasicPopulateSwitchCodeFixProvider())
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function AllMembersAndElseExist() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function AllMembersExist_NotElse() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_NotElse() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_WithElse() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_NotElse_EnumHasExplicitType() As Task
Dim markup =
<File>
Enum MyEnum As Long
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum As Long
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_WithMembersAndElseInBlock_NewValuesAboveElseBlock() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case MyEnum.Buzz
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NoMembersExist() As Task
Dim markup =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function ImportsEnum_AllMembersExist() As Task
Dim markup =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case [|e|]
Case CreateNew
Exit Select
Case Create
Exit Select
Case Open
Exit Select
Case OpenOrCreate
Exit Select
Case Truncate
Exit Select
Case Append
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function ImportsEnum_AllMembersExist_OutOfDefaultOrder() As Task
Dim markup =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case [|e|]
Case Truncate
Exit Select
Case Append
Exit Select
Case CreateNew
Exit Select
Case Open
Exit Select
Case OpenOrCreate
Exit Select
Case Create
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function ImportsEnum_NotAllMembersExist() As Task
Dim markup =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case [|e|]
Case CreateNew
Exit Select
Case Create
Exit Select
Case Open
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case e
Case CreateNew
Exit Select
Case Create
Exit Select
Case Open
Exit Select
Case System.IO.FileMode.OpenOrCreate
Exit Select
Case System.IO.FileMode.Truncate
Exit Select
Case System.IO.FileMode.Append
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function ImportsEnum_NoMembersExist() As Task
Dim markup =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case [|e|]
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Imports System.IO.FileMode
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = CreateNew
Select Case e
Case System.IO.FileMode.CreateNew
Exit Select
Case System.IO.FileMode.Create
Exit Select
Case System.IO.FileMode.Open
Exit Select
Case System.IO.FileMode.OpenOrCreate
Exit Select
Case System.IO.FileMode.Truncate
Exit Select
Case System.IO.FileMode.Append
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumIsFlags() As Task
Dim markup =
<File>
Imports System
&lt;Flags&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumIsFlagsAttribute() As Task
Dim markup =
<File>
Imports System
&lt;FlagsAttribute&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumIsFullyQualifiedSystemFlags() As Task
Dim markup =
<File>
&lt;System.Flags&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumIsFullyQualifiedSystemFlagsAttribute() As Task
Dim markup =
<File>
&lt;System.FlagsAttribute&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumHasNonFlagsAttribute() As Task
Dim markup =
<File>
&lt;System.Obsolete&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
&lt;System.Obsolete&gt;
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_EnumIsNested() As Task
Dim markup =
<File>
Class Foo
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Sub Bar()
Dim e = MyEnum.Fizz
Select Case [|e|]
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
End Select
End Sub
End Class
</File>
Dim expected =
<File>
Class Foo
Enum MyEnum
Fizz
Buzz
FizzBuzz
End Enum
Sub Bar()
Dim e = MyEnum.Fizz
Select Case e
Case MyEnum.Fizz
Exit Select
Case MyEnum.Buzz
Exit Select
Case MyEnum.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class
</File>
Await TestAsync(markup, expected, compareTokens:=False)
End Function
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
Public Async Function NotAllMembersExist_SwitchIsNotEnum() As Task
Dim markup =
<File>
Class Foo
Sub Bar()
Dim e = "Test"
Select Case [|e|]
Case "Fizz"
Exit Select
Case Test"
Exit Select
End Select
End Sub
End Class
</File>
Await TestMissingAsync(markup)
End Function
End Class
End Namespace
\ No newline at end of file
src/EditorFeatures/VisualBasicTest/PopulateSwitch/PopulateSwitchTests_FixAllTests.vb 已删除 100644 → 0
浏览文件 @ 17cf310d
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.PopulateSwitch
Partial Public Class PopulateSwitchTests
Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest
<Fact>
<Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
<Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)>
Public Async Function TestFixAllInDocument() As Task
Dim input = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case {|FixAllInDocument:e|}
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case Else
Exit Select
End Select
Select Case e
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Dim expected = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case e
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
Select Case e
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Await TestAsync(input, expected, compareTokens:=False, fixAllActionEquivalenceKey:=Nothing)
End Function
<Fact>
<Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
<Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)>
Public Async Function TestFixAllInProject() As Task
Dim input = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case {|FixAllInProject:e|}
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.Buzz
Exit Select
Case MyEnum2.FizzBuzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
Case MyEnum3.FizzBuzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Dim expected = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case e
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.Buzz
Exit Select
Case MyEnum2.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
Case MyEnum3.FizzBuzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Await TestAsync(input, expected, compareTokens:=False, fixAllActionEquivalenceKey:=Nothing)
End Function
<Fact>
<Trait(Traits.Feature, Traits.Features.CodeActionsPopulateSwitch)>
<Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)>
Public Async Function TestFixAllInSolution() As Task
Dim input = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case {|FixAllInSolution:e|}
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.Buzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Dim expected = <Workspace>
<Project Language="Visual Basic" AssemblyName="Assembly1" CommonReferences="true">
<Document><![CDATA[
Enum MyEnum1
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum1.Fizz
Select Case e
Case MyEnum1.Fizz
Exit Select
Case MyEnum1.Buzz
Exit Select
Case MyEnum1.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
<Document><![CDATA[
Enum MyEnum2
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum2.Fizz
Select Case e
Case MyEnum2.Fizz
Exit Select
Case MyEnum2.Buzz
Exit Select
Case MyEnum2.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
<Project Language="Visual Basic" AssemblyName="Assembly2" CommonReferences="true">
<ProjectReference>Assembly1</ProjectReference>
<Document><![CDATA[
Enum MyEnum3
Fizz
Buzz
FizzBuzz
End Enum
Class Foo
Sub Bar()
Dim e = MyEnum3.Fizz
Select Case e
Case MyEnum3.Fizz
Exit Select
Case MyEnum3.Buzz
Exit Select
Case MyEnum3.FizzBuzz
Exit Select
Case Else
Exit Select
End Select
End Sub
End Class]]>
</Document>
</Project>
</Workspace>.ToString()
Await TestAsync(input, expected, compareTokens:=False, fixAllActionEquivalenceKey:=Nothing)
End Function
End Class
End Namespace
\ No newline at end of file
src/Features/CSharp/Portable/CSharpFeatures.csproj
浏览文件 @ 735cbe97
......@@ -349,9 +349,6 @@
<Compile Include="Organizing\Organizers\OperatorDeclarationOrganizer.cs" />
<Compile Include="Organizing\Organizers\PropertyDeclarationOrganizer.cs" />
<Compile Include="Organizing\Organizers\StructDeclarationOrganizer.cs" />
<Compile Include="PopulateSwitch\CSharpPopulateSwitchCodeFixProvider.cs" />
<Compile Include="PopulateSwitch\CSharpPopulateSwitchDiagnosticAnalyzer.cs" />
<Compile Include="PopulateSwitch\CSharpPopulateSwitchHelpers.cs" />
<Compile Include="RemoveUnnecessaryImports\CSharpRemoveUnnecessaryImportsService.cs" />
<Compile Include="RemoveUnnecessaryImports\CSharpRemoveUnnecessaryImportsService.Rewriter.cs" />
<Compile Include="ReplaceMethodWithProperty\CSharpReplaceMethodWithPropertyService.cs" />
......
src/Features/CSharp/Portable/PopulateSwitch/CSharpPopulateSwitchCodeFixProvider.cs 已删除 100644 → 0
浏览文件 @ 17cf310d
using System.Collections.Generic;
using System.Composition;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp.PopulateSwitch;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Text;
namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.PopulateSwitch
{
[ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.PopulateSwitch), Shared]
[ExtensionOrder(After = PredefinedCodeFixProviderNames.ImplementInterface)]
internal class CSharpPopulateSwitchCodeFixProvider : AbstractPopulateSwitchCodeFixProvider<SwitchStatementSyntax, ExpressionSyntax, SwitchSectionSyntax>
{
protected override ExpressionSyntax GetSwitchExpression(SwitchStatementSyntax switchStatement) => switchStatement.Expression;
protected override int InsertPosition(SyntaxList<SwitchSectionSyntax> sections) => sections.Count - 1;
protected override SyntaxList<SwitchSectionSyntax> GetSwitchSections(SwitchStatementSyntax switchStatement)
=> switchStatement.Sections;
protected override SwitchStatementSyntax NewSwitchNode(SwitchStatementSyntax switchStatement, SyntaxList<SwitchSectionSyntax> sections) =>
switchStatement.WithSections(SyntaxFactory.List(sections));
protected override List<ExpressionSyntax> GetCaseLabels(SwitchStatementSyntax switchStatement, out bool containsDefaultLabel)
=> CSharpPopulateSwitchHelpers.GetCaseLabels(switchStatement, out containsDefaultLabel);
}
}
src/Features/CSharp/Portable/PopulateSwitch/CSharpPopulateSwitchDiagnosticAnalyzer.cs 已删除 100644 → 0
浏览文件 @ 17cf310d
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Diagnostics.PopulateSwitch;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Generic;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis.CSharp.PopulateSwitch;
namespace Microsoft.CodeAnalysis.CSharp.Diagnostics.PopulateSwitch
{
[DiagnosticAnalyzer(LanguageNames.CSharp)]
internal sealed class CSharpPopulateSwitchDiagnosticAnalyzer : AbstractPopulateSwitchDiagnosticAnalyzerBase<SyntaxKind, SwitchStatementSyntax, ExpressionSyntax>
{
protected override ImmutableArray<SyntaxKind> SyntaxKindsOfInterest { get; } = ImmutableArray.Create(SyntaxKind.SwitchStatement);
protected override ExpressionSyntax GetExpression(SwitchStatementSyntax switchBlock) => switchBlock.Expression;
protected override List<ExpressionSyntax> GetCaseLabels(SwitchStatementSyntax switchBlock, out bool hasDefaultCase)
=> CSharpPopulateSwitchHelpers.GetCaseLabels(switchBlock, out hasDefaultCase);
}
}
src/Features/CSharp/Portable/PopulateSwitch/CSharpPopulateSwitchHelpers.cs 已删除 100644 → 0
浏览文件 @ 17cf310d
using System.Collections.Generic;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace Microsoft.CodeAnalysis.CSharp.PopulateSwitch
{
internal static class CSharpPopulateSwitchHelpers
{
public static List<ExpressionSyntax> GetCaseLabels(SwitchStatementSyntax switchStatement, out bool containsDefaultLabel)
{
containsDefaultLabel = false;
var caseLabels = new List<ExpressionSyntax>();
foreach (var section in switchStatement.Sections)
{
foreach (var label in section.Labels)
{
var caseLabel = label as CaseSwitchLabelSyntax;
if (caseLabel != null)
{
caseLabels.Add(caseLabel.Value);
}
if (label.IsKind(SyntaxKind.DefaultSwitchLabel))
{
containsDefaultLabel = true;
}
}
}
return caseLabels;
}
}
}
\ No newline at end of file
src/Features/VisualBasic/Portable/BasicFeatures.vbproj
浏览文件 @ 735cbe97
......@@ -116,8 +116,6 @@
<Compile Include="CodeFixes\MoveToTopOfFile\MoveToTopOfFileCodeFixProvider.vb" />
<Compile Include="CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.AddOverloads.vb" />
<Compile Include="CodeFixes\OverloadBase\OverloadBaseCodeFixProvider.vb" />
<Compile Include="PopulateSwitch\VisualBasicPopulateSwitchCodeFixProvider.vb" />
<Compile Include="PopulateSwitch\VisualBasicPopulateSwitchDiagnosticAnalyzer.vb" />
<Compile Include="CodeFixes\RemoveUnnecessaryCast\RemoveUnnecessaryCastCodeFixProvider.RemoveUnnecessaryCastFixAllProvider.vb" />
<Compile Include="CodeFixes\RemoveUnnecessaryCast\RemoveUnnecessaryCastCodeFixProvider.Rewriter.vb" />
<Compile Include="CodeFixes\RemoveUnnecessaryCast\RemoveUnnecessaryCastCodeFixProvider.vb" />
......@@ -369,7 +367,6 @@
<Compile Include="Organizing\Organizers\TypeBlockOrganizer.vb" />
<Compile Include="Organizing\VisualBasicOrganizerService.Rewriter.vb" />
<Compile Include="Organizing\VisualBasicOrganizerService.vb" />
<Compile Include="PopulateSwitch\VisualBasicPopulateSwitchHelpers.vb" />
<Compile Include="RemoveUnnecessaryImports\VisualBasicRemoveUnnecessaryImportsService.Rewriter.vb" />
<Compile Include="RemoveUnnecessaryImports\VisualBasicRemoveUnnecessaryImportsService.vb" />
<Compile Include="RemoveUnnecessaryImports\VisualBasicRemoveUnnecessaryImportsService.Visitor.vb" />
......
src/Features/VisualBasic/Portable/PopulateSwitch/VisualBasicPopulateSwitchCodeFixProvider.vb 已删除 100644 → 0
浏览文件 @ 17cf310d
Imports System.Composition
Imports System.Runtime.InteropServices
Imports Microsoft.CodeAnalysis.CodeFixes
Imports Microsoft.CodeAnalysis.CSharp.CodeFixes.PopulateSwitch
Imports Microsoft.CodeAnalysis.Text
Imports Microsoft.CodeAnalysis.VisualBasic.PopulateSwitch
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.PopulateSwitch
<ExportCodeFixProvider(LanguageNames.VisualBasic, Name:=PredefinedCodeFixProviderNames.PopulateSwitch), [Shared]>
<ExtensionOrder(After:=PredefinedCodeFixProviderNames.AddOverloads)>
Partial Friend Class VisualBasicPopulateSwitchCodeFixProvider
Inherits AbstractPopulateSwitchCodeFixProvider(Of SelectBlockSyntax, ExpressionSyntax, CaseBlockSyntax)
Protected Overrides Function GetSwitchExpression(selectBlock As SelectBlockSyntax) As ExpressionSyntax
Return selectBlock.SelectStatement.Expression
End Function
Protected Overrides Function InsertPosition(sections As SyntaxList(Of CaseBlockSyntax)) As Integer
Dim cases = sections.OfType(Of CaseBlockSyntax).ToList()
Dim numOfBlocksWithNoStatementsWithElse = 0
' skip the `Else` block
For i = cases.Count - 2 To 0 Step -1
If Not cases.ElementAt(i).Statements.Count = 0
' insert the values immediately below the last item with statements
numOfBlocksWithNoStatementsWithElse = i + 1
Exit For
End If
Next
Return numOfBlocksWithNoStatementsWithElse
End Function
Protected Overrides Function GetSwitchSections(selectBlock As SelectBlockSyntax) As SyntaxList(Of CaseBlockSyntax)
Return selectBlock.CaseBlocks
End Function
Protected Overrides Function NewSwitchNode(selectBlock As SelectBlockSyntax, sections As SyntaxList(Of CaseBlockSyntax)) As SelectBlockSyntax
Return selectBlock.WithCaseBlocks(SyntaxFactory.List(sections))
End Function
Protected Overrides Function GetCaseLabels(selectBlock As SelectBlockSyntax, <Out> ByRef containsDefaultLabel As Boolean) As List(Of ExpressionSyntax)
Return VisualBasicPopulateSwitchHelperClass.GetCaseLabels(selectBlock, containsDefaultLabel)
End Function
End Class
End Namespace
\ No newline at end of file
src/Features/VisualBasic/Portable/PopulateSwitch/VisualBasicPopulateSwitchDiagnosticAnalyzer.vb 已删除 100644 → 0
浏览文件 @ 17cf310d
Imports System.Collections.Immutable
Imports System.Runtime.InteropServices
Imports Microsoft.CodeAnalysis.Diagnostics
Imports Microsoft.CodeAnalysis.Diagnostics.PopulateSwitch
Imports Microsoft.CodeAnalysis.VisualBasic.PopulateSwitch
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Namespace Microsoft.CodeAnalysis.VisualBasic.Diagnostics.PopulateSwitch
<DiagnosticAnalyzer(LanguageNames.VisualBasic)>
Friend NotInheritable Class VisualBasicPopulateSwitchDiagnosticAnalyzer
Inherits AbstractPopulateSwitchDiagnosticAnalyzerBase(Of SyntaxKind, SelectBlockSyntax, ExpressionSyntax)
Protected Overrides Function GetCaseLabels(selectBlock As SelectBlockSyntax, <Out> ByRef hasDefaultCase As Boolean) As List(Of ExpressionSyntax)
Return VisualBasicPopulateSwitchHelperClass.GetCaseLabels(selectBlock, hasDefaultCase)
End Function
Protected Overrides ReadOnly Property SyntaxKindsOfInterest As ImmutableArray(Of SyntaxKind) = ImmutableArray.Create(SyntaxKind.SelectBlock)
Protected Overrides Function GetExpression(selectBlock As SelectBlockSyntax) As ExpressionSyntax
Return selectBlock.SelectStatement.Expression
End Function
End Class
End Namespace
src/Features/VisualBasic/Portable/PopulateSwitch/VisualBasicPopulateSwitchHelpers.vb 已删除 100644 → 0
浏览文件 @ 17cf310d
Imports System.Runtime.InteropServices
Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
Namespace Microsoft.CodeAnalysis.VisualBasic.PopulateSwitch
Friend Module VisualBasicPopulateSwitchHelperClass
Public Function GetCaseLabels(selectBlock As SelectBlockSyntax, <Out> ByRef containsDefaultLabel As Boolean) As List(Of ExpressionSyntax)
containsDefaultLabel = False
Dim caseLabels = New List(Of ExpressionSyntax)
For Each block In selectBlock.CaseBlocks
For Each caseSyntax In block.CaseStatement.Cases
Dim simpleCaseClause = TryCast(caseSyntax, SimpleCaseClauseSyntax)
If Not simpleCaseClause Is Nothing
caseLabels.Add(simpleCaseClause.Value)
Continue For
End If
If caseSyntax.IsKind(SyntaxKind.ElseCaseClause)
containsDefaultLabel = True
End If
Next
Next
Return caseLabels
End Function
End Module
End Namespace
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或