Skip to content

R
roslyn

lwm1986 / roslyn
与 Fork 源项目一致

从无法访问的项目Fork

通知 1
Star 0
Fork 0
R
roslyn

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

提交 dd09aa5b 编写于 作者: S Sam Harwell
浏览文件
操作

Use strongly-typed option values

上级 eee99604
隐藏空白更改
内联 并排
Showing with 753 addition and 517 deletion
src/Analyzers/CSharp/Tests/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProviderTests.cs
浏览文件 @ dd09aa5b
......@@ -11,7 +11,7 @@
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.MisplacedUsingDirectives
......@@ -54,7 +54,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
protected const string DelegateDefinition = @"public delegate void TestDelegate();";
private TestParameters GetTestParameters(CodeStyleOption2<AddImportPlacement> preferredPlacementOption)
=> new TestParameters(options: OptionsSet((new OptionKey2(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement), preferredPlacementOption)));
=> new TestParameters(options: new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, preferredPlacementOption } });
private protected Task TestDiagnosticMissingAsync(string initialMarkup, CodeStyleOption2<AddImportPlacement> preferredPlacementOption)
=> TestDiagnosticMissingAsync(initialMarkup, GetTestParameters(preferredPlacementOption));
......@@ -64,11 +64,11 @@ private protected Task TestMissingAsync(string initialMarkup, CodeStyleOption2<A
private protected Task TestInRegularAndScriptAsync(string initialMarkup, string expectedMarkup, CodeStyleOption2<AddImportPlacement> preferredPlacementOption, bool placeSystemNamespaceFirst)
{
var options = OptionsSet
(
(new OptionKey2(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement), preferredPlacementOption),
(new OptionKey2(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp), placeSystemNamespaceFirst)
);
var options = new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, preferredPlacementOption },
{ GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst },
};
return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options: options);
}
......
src/Analyzers/CSharp/Tests/UseConditionalExpression/UseConditionalExpressionForAssignmentTests.cs
浏览文件 @ dd09aa5b
......@@ -23,12 +23,12 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
=> (new CSharpUseConditionalExpressionForAssignmentDiagnosticAnalyzer(),
new CSharpUseConditionalExpressionForAssignmentCodeFixProvider());
private OptionsCollection PreferImplicitTypeAlways => OptionsSet
(
(CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSilentEnforcement),
(CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSilentEnforcement),
(CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions2.TrueWithSilentEnforcement)
);
private OptionsCollection PreferImplicitTypeAlways => new OptionsCollection(LanguageNames.CSharp)
{
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSilentEnforcement },
{ CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSilentEnforcement },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, CodeStyleOptions2.TrueWithSilentEnforcement },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseConditionalExpression)]
public async Task TestOnSimpleAssignment()
......
src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForAccessorsAnalyzerTests.cs
浏览文件 @ dd09aa5b
......@@ -23,22 +23,28 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
=> (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider());
private OptionsCollection UseExpressionBody =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement },
};
private OptionsCollection UseExpressionBodyIncludingPropertiesAndIndexers =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
};
private OptionsCollection UseBlockBodyIncludingPropertiesAndIndexers =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSuggestionEnforcement },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
public async Task TestUseExpressionBody1()
......@@ -305,10 +311,12 @@ int Goo
public async Task TestUseBlockBody5()
{
var whenOnSingleLineWithNoneEnforcement = new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenOnSingleLine, NotificationOption2.None);
var options = OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, whenOnSingleLineWithNoneEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, whenOnSingleLineWithNoneEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, whenOnSingleLineWithNoneEnforcement));
var options = new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, whenOnSingleLineWithNoneEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, whenOnSingleLineWithNoneEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, whenOnSingleLineWithNoneEnforcement },
};
await TestMissingInRegularAndScriptAsync(
@"class C
......
src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForIndexersAnalyzerTests.cs
浏览文件 @ dd09aa5b
......@@ -21,19 +21,25 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
=> (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider());
private OptionsCollection UseExpressionBody =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBody =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyExceptAccessor =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
public async Task TestUseExpressionBody1()
......
src/Analyzers/CSharp/Tests/UseExpressionBody/UseExpressionBodyForPropertiesAnalyzerTests.cs
浏览文件 @ dd09aa5b
......@@ -22,19 +22,25 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
=> (new UseExpressionBodyDiagnosticAnalyzer(), new UseExpressionBodyCodeFixProvider());
private OptionsCollection UseExpressionBody =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBody =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyExceptAccessor =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
public async Task TestUseExpressionBody1()
......
src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs
浏览文件 @ dd09aa5b
......@@ -31,30 +31,45 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private readonly CodeStyleOption2<bool> offWithError = new CodeStyleOption2<bool>(false, NotificationOption2.Error);
// specify all options explicitly to override defaults.
private OptionsCollection ExplicitTypeEverywhere() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
private OptionsCollection ExplicitTypeExceptWhereApparent() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
private OptionsCollection ExplicitTypeForBuiltInTypesOnly() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
private OptionsCollection ExplicitTypeEnforcements() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
private OptionsCollection ExplicitTypeSilentEnforcement() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent));
private OptionsCollection ExplicitTypeEverywhere() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
private OptionsCollection ExplicitTypeExceptWhereApparent() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
private OptionsCollection ExplicitTypeForBuiltInTypesOnly() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
private OptionsCollection ExplicitTypeEnforcements() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithWarning },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
private OptionsCollection ExplicitTypeSilentEnforcement() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent },
};
#region Error Cases
......
src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseImplicitTypeTests.cs
浏览文件 @ dd09aa5b
......@@ -32,35 +32,53 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private static readonly CodeStyleOption2<bool> offWithError = new CodeStyleOption2<bool>(false, NotificationOption2.Error);
// specify all options explicitly to override defaults.
internal OptionsCollection ImplicitTypeEverywhere() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
private OptionsCollection ImplicitTypeWhereApparent() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
private OptionsCollection ImplicitTypeWhereApparentAndForIntrinsics() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
internal OptionsCollection ImplicitTypeButKeepIntrinsics() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo));
private OptionsCollection ImplicitTypeEnforcements() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
private OptionsCollection ImplicitTypeSilentEnforcement() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
internal OptionsCollection ImplicitTypeEverywhere() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
private OptionsCollection ImplicitTypeWhereApparent() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
private OptionsCollection ImplicitTypeWhereApparentAndForIntrinsics() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
internal OptionsCollection ImplicitTypeButKeepIntrinsics() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
};
private OptionsCollection ImplicitTypeEnforcements() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithWarning },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
private OptionsCollection ImplicitTypeSilentEnforcement() =>
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent },
};
[WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsUseImplicitType)]
public async Task NotOnFieldDeclaration()
......
src/Analyzers/CSharp/Tests/UseVarTestExtensions.cs
浏览文件 @ dd09aa5b
......@@ -26,63 +26,83 @@ internal static class UseVarTestExtensions
private static readonly CodeStyleOption2<bool> onWithError = new CodeStyleOption2<bool>(true, NotificationOption2.Error);
public static OptionsCollection PreferExplicitTypeWithError(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithError),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithError));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithError },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithError },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithError },
};
public static OptionsCollection PreferImplicitTypeWithError(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithError),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithError));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithError },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithError },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithError },
};
public static OptionsCollection PreferExplicitTypeWithWarning(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithWarning),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithWarning),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithWarning));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithWarning },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithWarning },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithWarning },
};
public static OptionsCollection PreferImplicitTypeWithWarning(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithWarning),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithWarning),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithWarning));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithWarning },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithWarning },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithWarning },
};
public static OptionsCollection PreferExplicitTypeWithInfo(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithInfo),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithInfo },
};
public static OptionsCollection PreferImplicitTypeWithInfo(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
public static OptionsCollection PreferExplicitTypeWithSilent(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithSilent),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithSilent },
};
public static OptionsCollection PreferImplicitTypeWithSilent(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent },
};
public static OptionsCollection PreferExplicitTypeWithNone(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, offWithNone),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithNone),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, offWithNone));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, offWithNone },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, offWithNone },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, offWithNone },
};
public static OptionsCollection PreferImplicitTypeWithNone(this AbstractCodeActionOrUserDiagnosticTest test)
=> test.OptionsSet(
test.SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithNone),
test.SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithNone),
test.SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithNone));
=> new OptionsCollection(test.GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithNone },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithNone },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithNone },
};
}
}
src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs
浏览文件 @ dd09aa5b
......@@ -21,6 +21,7 @@ public class ValidateFormatStringTests : AbstractCSharpDiagnosticProviderBasedUs
internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
=> (new CSharpValidateFormatStringDiagnosticAnalyzer(), null);
#pragma warning disable CS0618 // Type or member is obsolete
private OptionsCollection CSharpOptionOffVBOptionOn() => OptionsSet(
(new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), false),
(new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), true));
......@@ -28,6 +29,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private OptionsCollection CSharpOptionOnVBOptionOff() => OptionsSet(
(new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), true),
(new OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), false));
#pragma warning restore CS0618 // Type or member is obsolete
[Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
public async Task OnePlaceholder()
......
src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb
浏览文件 @ dd09aa5b
......@@ -19,6 +19,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ValidateFormatStri
Return (New VisualBasicValidateFormatStringDiagnosticAnalyzer, Nothing)
End Function
#Disable Warning BC40000 ' Type or member is obsolete
Private Function VBOptionOnCSharpOptionOff() As OptionsCollection
Return OptionsSet(
(New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), False),
......@@ -30,6 +31,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ValidateFormatStri
(New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.CSharp), True),
(New OptionKey2(ValidateFormatStringOption.ReportInvalidPlaceholdersInStringDotFormatCalls, LanguageNames.VisualBasic), False))
End Function
#Enable Warning BC40000 ' Type or member is obsolete
<Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)>
Public Async Function ParamsObjectArray() As Task
......
src/CodeStyle/CSharp/Tests/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.cs
浏览文件 @ dd09aa5b
......@@ -2,6 +2,7 @@
// 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;
using Microsoft.CodeAnalysis.CodeStyle;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Options;
......@@ -32,23 +33,24 @@ internal static (OptionKey2, object) SingleOption<T>(PerLanguageOption2<CodeStyl
=> (new OptionKey2(option, language), codeStyle);
internal OptionsCollection Option<T>(Option2<CodeStyleOption2<T>> option, T enabled, NotificationOption2 notification)
=> OptionsSet(SingleOption(option, enabled, notification));
=> new OptionsCollection(GetLanguage()) { { option, enabled, notification } };
internal OptionsCollection Option<T>(Option2<CodeStyleOption2<T>> option, CodeStyleOption2<T> codeStyle)
=> OptionsSet(SingleOption(option, codeStyle));
=> new OptionsCollection(GetLanguage()) { { option, codeStyle } };
internal OptionsCollection Option<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T enabled, NotificationOption2 notification)
=> OptionsSet(SingleOption(option, enabled, notification));
=> new OptionsCollection(GetLanguage()) { { option, enabled, notification } };
internal OptionsCollection Option<T>(PerLanguageOption2<CodeStyleOption2<T>> option, CodeStyleOption2<T> codeStyle)
=> OptionsSet(SingleOption(option, codeStyle));
=> new OptionsCollection(GetLanguage()) { { option, codeStyle } };
internal OptionsCollection Option<T>(Option2<T> option, T value)
=> OptionsSet(SingleOption(option, value));
=> new OptionsCollection(GetLanguage()) { { option, value } };
internal OptionsCollection Option<T>(PerLanguageOption2<T> option, T value)
=> OptionsSet(SingleOption(option, value));
=> new OptionsCollection(GetLanguage()) { { option, value } };
[Obsolete("Use a strongly-typed overload instead.")]
internal OptionsCollection OptionsSet(params (OptionKey2 key, object value)[] options)
=> new OptionsCollection(LanguageNames.CSharp, options);
}
......
src/CodeStyle/VisualBasic/Tests/AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_OptionHelpers.vb
浏览文件 @ dd09aa5b
......@@ -2,8 +2,8 @@
' The .NET Foundation licenses this file to you under the MIT license.
' See the LICENSE file in the project root for more information.
Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.CodeStyle
Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.Options
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
......@@ -38,29 +38,30 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
End Function
Friend Function [Option](Of T)(optionParam As Option2(Of CodeStyleOption2(Of T)), enabled As T, notification As NotificationOption2) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, enabled, notification))
Return New OptionsCollection(GetLanguage()) From {{optionParam, enabled, notification}}
End Function
Friend Function [Option](Of T)(optionParam As Option2(Of CodeStyleOption2(Of T)), codeStyle As CodeStyleOption2(Of T)) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, codeStyle))
Return New OptionsCollection(GetLanguage()) From {{optionParam, codeStyle}}
End Function
Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of CodeStyleOption2(Of T)), enabled As T, notification As NotificationOption2) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, enabled, notification))
Return New OptionsCollection(GetLanguage()) From {{optionParam, enabled, notification}}
End Function
Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of CodeStyleOption2(Of T)), codeStyle As CodeStyleOption2(Of T)) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, codeStyle))
Return New OptionsCollection(GetLanguage()) From {{optionParam, codeStyle}}
End Function
Friend Function [Option](Of T)(optionParam As Option2(Of T), value As T) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, value))
Return New OptionsCollection(GetLanguage()) From {{optionParam, value}}
End Function
Friend Function [Option](Of T)(optionParam As PerLanguageOption2(Of T), value As T) As OptionsCollection
Return OptionsSet(SingleOption(optionParam, value))
Return New OptionsCollection(GetLanguage()) From {{optionParam, value}}
End Function
<Obsolete("Use a strongly-typed overload instead.")>
Friend Shared Function OptionsSet(ParamArray options As (OptionKey2, Object)()) As OptionsCollection
Return New OptionsCollection(LanguageNames.VisualBasic, options)
End Function
......
src/EditorFeatures/CSharpTest/AddUsing/AddUsingTestsWithAddImportDiagnosticProvider.cs
浏览文件 @ dd09aa5b
......@@ -10,7 +10,6 @@
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
......@@ -30,7 +29,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
{
return TestInRegularAndScriptAsync(initialMarkup, expected, index: index, options: new OptionsCollection(LanguageNames.CSharp)
{
{ new OptionKey2(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp), systemSpecialCase }
{ GenerationOptions.PlaceSystemNamespaceFirst, systemSpecialCase }
});
}
......
src/EditorFeatures/CSharpTest/ChangeSignature/ChangeSignature_Delegates.cs
浏览文件 @ dd09aa5b
......@@ -19,7 +19,7 @@ public partial class ChangeSignatureTests : AbstractChangeSignatureTests
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
=> new ChangeSignatureCodeRefactoringProvider();
protected override string GetLanguage()
protected internal override string GetLanguage()
=> LanguageNames.CSharp;
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
......
src/EditorFeatures/CSharpTest/CodeActions/AbstractCSharpCodeActionTest.cs
浏览文件 @ dd09aa5b
......@@ -12,7 +12,7 @@ public abstract class AbstractCSharpCodeActionTest : AbstractCodeActionTest
{
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
......
src/EditorFeatures/CSharpTest/CodeActions/EncapsulateField/EncapsulateFieldTests.cs
浏览文件 @ dd09aa5b
......@@ -12,7 +12,6 @@
using Microsoft.CodeAnalysis.EncapsulateField;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.EncapsulateField
......@@ -23,9 +22,11 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa
=> new EncapsulateFieldRefactoringProvider();
private OptionsCollection AllOptionsOff =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
internal Task TestAllOptionsOffAsync(
string initialMarkup, string expectedMarkup,
......@@ -34,10 +35,7 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa
int index = 0, OptionsCollection options = null)
{
options = options ?? new OptionsCollection(GetLanguage());
foreach (var (key, value) in AllOptionsOff)
{
options.Add(key, value);
}
options.AddRange(AllOptionsOff);
return TestAsync(initialMarkup, expectedMarkup,
parseOptions, compilationOptions, index, options);
......@@ -209,9 +207,11 @@ void baz()
}
";
await TestInRegularAndScriptAsync(text, expected,
options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent)));
options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent },
});
}
[Fact, Trait(Traits.Feature, Traits.Features.EncapsulateField)]
......
src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs
浏览文件 @ dd09aa5b
......@@ -29,11 +29,13 @@ protected override ImmutableArray<CodeAction> MassageActions(ImmutableArray<Code
private readonly CodeStyleOption2<bool> onWithInfo = new CodeStyleOption2<bool>(true, NotificationOption2.Suggestion);
// specify all options explicitly to override defaults.
private OptionsCollection ImplicitTypingEverywhere() =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
private OptionsCollection ImplicitTypingEverywhere()
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
public async Task TestEmptySpan1()
......
src/EditorFeatures/CSharpTest/CodeActions/MoveType/CSharpMoveTypeTestsBase.cs
浏览文件 @ dd09aa5b
......@@ -12,7 +12,7 @@ public abstract class CSharpMoveTypeTestsBase : AbstractMoveTypeTest
{
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
{
......
src/EditorFeatures/CSharpTest/CodeActions/ReplaceMethodWithProperty/ReplaceMethodWithPropertyTests.cs
浏览文件 @ dd09aa5b
......@@ -1902,9 +1902,11 @@ int Goo
e;
}
}
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement },
});
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsReplaceMethodWithProperty)]
......@@ -2368,20 +2370,32 @@ int Goo1
options: AllCodeStyleOff);
}
private OptionsCollection AllCodeStyleOff =>
OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection AllCodeStyleOff
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection PreferExpressionBodiedAccessors =>
OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection PreferExpressionBodiedAccessors
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection PreferExpressionBodiedProperties =>
OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement));
private OptionsCollection PreferExpressionBodiedProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
};
private OptionsCollection PreferExpressionBodiedAccessorsAndProperties =>
OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement));
private OptionsCollection PreferExpressionBodiedAccessorsAndProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement },
};
}
}
src/EditorFeatures/CSharpTest/CodeActions/ReplacePropertyWithMethods/ReplacePropertyWithMethodsTests.cs
浏览文件 @ dd09aa5b
......@@ -1844,6 +1844,6 @@ public static void Set(int value)
}
private OptionsCollection PreferExpressionBodiedMethods =>
OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement));
new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement } };
}
}
src/EditorFeatures/CSharpTest/CodeActions/SyncNamespace/CSharpSyncNamespaceTestsBase.cs
浏览文件 @ dd09aa5b
......@@ -24,7 +24,7 @@ public abstract class CSharpSyncNamespaceTestsBase : AbstractCodeActionTest
{
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
=> new CSharpSyncNamespaceCodeRefactoringProvider();
......
src/EditorFeatures/CSharpTest/CodeRefactorings/AddMissingImports/CSharpAddMissingImportsRefactoringProviderTests.cs
浏览文件 @ dd09aa5b
......@@ -8,6 +8,7 @@
using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.AddMissingImports;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
using Microsoft.CodeAnalysis.PasteTracking;
using Microsoft.CodeAnalysis.Test.Utilities;
......@@ -52,9 +53,12 @@ protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, T
string initialMarkup, string expectedMarkup,
bool placeSystemNamespaceFirst, bool separateImportDirectiveGroups)
{
var options = OptionsSet(
SingleOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst),
SingleOption(GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups));
var options =
new OptionsCollection(GetLanguage())
{
{ GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst },
{ GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups },
};
return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options: options);
}
......
src/EditorFeatures/CSharpTest/ConvertAutoPropertyToFullProperty/ConvertAutoPropertyToFullPropertyTests_OptionSets.cs
浏览文件 @ dd09aa5b
......@@ -19,43 +19,55 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertAutoPropertyToFu
public partial class ConvertAutoPropertyToFullPropertyTests : AbstractCSharpCodeActionTest
{
private OptionsCollection PreferExpressionBodiedAccessorsWhenPossible
=> OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement));
=> new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement } };
private OptionsCollection PreferExpressionBodiedAccessorsWhenOnSingleLine
=> OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement));
=> new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenOnSingleLineWithSilentEnforcement } };
private OptionsCollection DoNotPreferExpressionBodiedAccessors
=> OptionsSet(SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
=> new OptionsCollection(GetLanguage()) { { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement } };
private OptionsCollection DoNotPreferExpressionBodiedAccessorsAndPropertyOpenBraceOnSameLine
=> OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpFormattingOptions2.NewLinesForBracesInProperties, false));
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpFormattingOptions2.NewLinesForBracesInProperties, false },
};
private OptionsCollection DoNotPreferExpressionBodiedAccessorsAndAccessorOpenBraceOnSameLine
=> OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpFormattingOptions2.NewLinesForBracesInAccessors, false));
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpFormattingOptions2.NewLinesForBracesInAccessors, false },
};
private OptionsCollection PreferExpressionBodiesOnAccessorsAndMethods
=> OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection UseCustomFieldName
=> OptionsSet(
SingleOption(NamingStyleOptions.NamingPreferences, CreateCustomFieldNamingStylePreference()),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
=> new OptionsCollection(GetLanguage())
{
{ NamingStyleOptions.NamingPreferences, CreateCustomFieldNamingStylePreference() },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseUnderscorePrefixedFieldName
=> OptionsSet(
SingleOption(NamingStyleOptions.NamingPreferences, CreateUnderscorePrefixedFieldNamingStylePreference()),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
=> new OptionsCollection(GetLanguage())
{
{ NamingStyleOptions.NamingPreferences, CreateUnderscorePrefixedFieldNamingStylePreference() },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseCustomStaticFieldName
=> OptionsSet(
SingleOption(NamingStyleOptions.NamingPreferences, CreateCustomStaticFieldNamingStylePreference()),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
=> new OptionsCollection(GetLanguage())
{
{ NamingStyleOptions.NamingPreferences, CreateCustomStaticFieldNamingStylePreference() },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private NamingStylePreferences CreateCustomFieldNamingStylePreference()
{
......
src/EditorFeatures/CSharpTest/ConvertForEachToFor/ConvertForEachToForTests.cs
浏览文件 @ dd09aa5b
......@@ -24,10 +24,13 @@ public partial class ConvertForEachToForTests : AbstractCSharpCodeActionTest
private readonly CodeStyleOption2<bool> onWithSilent = new CodeStyleOption2<bool>(true, NotificationOption2.Silent);
private OptionsCollection ImplicitTypeEverywhere => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
private OptionsCollection ImplicitTypeEverywhere
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent },
};
[WorkItem(31621, "https://github.com/dotnet/roslyn/issues/31621")]
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForEachToFor)]
......
src/EditorFeatures/CSharpTest/ConvertForToForEach/ConvertForToForEachTests.cs
浏览文件 @ dd09aa5b
......@@ -23,10 +23,13 @@ protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspa
private readonly CodeStyleOption2<bool> onWithSilent = new CodeStyleOption2<bool>(true, NotificationOption2.Silent);
private OptionsCollection ImplicitTypeEverywhere() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent));
private OptionsCollection ImplicitTypeEverywhere()
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithSilent },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithSilent },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithSilent },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertForToForEach)]
public async Task TestArray1()
......
src/EditorFeatures/CSharpTest/Diagnostics/AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest.cs
浏览文件 @ dd09aa5b
......@@ -12,7 +12,7 @@ public abstract partial class AbstractCSharpDiagnosticProviderBasedUserDiagnosti
{
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/BooleanCodeStyleOptionConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -21,7 +21,7 @@ public abstract partial class BooleanCodeStyleOptionConfigurationTests : Abstrac
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/EnumCodeStyleOptionConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -21,7 +21,7 @@ public abstract partial class EnumCodeStyleOptionConfigurationTests : AbstractSu
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureCodeStyle/MultipleCodeStyleOptionConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -32,7 +32,7 @@ protected override ImmutableArray<CodeAction> MassageActions(ImmutableArray<Code
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/AllAnalyzersSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context)
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CSharpCodeStyleOptionBasedSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -22,7 +22,7 @@ public abstract partial class CSharpCodeStyleOptionBasedSeverityConfigurationTes
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CategoryBasedSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context)
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/CodeStyleOptionBasedSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -21,7 +21,7 @@ public abstract partial class CodeStyleOptionBasedSeverityConfigurationTests : A
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/DotNetDiagnosticSeverityBasedSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -42,7 +42,7 @@ public override void Initialize(AnalysisContext context)
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/Configuration/ConfigureSeverity/MultipleCodeStyleOptionBasedSeverityConfigurationTests.cs
浏览文件 @ dd09aa5b
......@@ -21,7 +21,7 @@ public abstract partial class MultipleCodeStyleOptionBasedSeverityConfigurationT
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override ParseOptions GetScriptOptions() => Options.Script;
......
src/EditorFeatures/CSharpTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.cs
浏览文件 @ dd09aa5b
......@@ -22,21 +22,33 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private readonly CodeStyleOption2<bool> onWithInfo = new CodeStyleOption2<bool>(true, NotificationOption2.Suggestion);
private readonly CodeStyleOption2<bool> offWithInfo = new CodeStyleOption2<bool>(false, NotificationOption2.Suggestion);
private OptionsCollection NoFrameworkType => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo, GetLanguage()));
private OptionsCollection FrameworkTypeEverywhere => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo, GetLanguage()));
private OptionsCollection FrameworkTypeInDeclaration => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo, GetLanguage()));
private OptionsCollection FrameworkTypeInMemberAccess => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo, GetLanguage()));
private OptionsCollection NoFrameworkType
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo },
};
private OptionsCollection FrameworkTypeEverywhere
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo },
};
private OptionsCollection FrameworkTypeInDeclaration
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, false, NotificationOption2.Suggestion },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, onWithInfo },
};
private OptionsCollection FrameworkTypeInMemberAccess
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Suggestion },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, offWithInfo },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseFrameworkType)]
public async Task NotWhenOptionsAreNotSet()
......
src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs
浏览文件 @ dd09aa5b
......@@ -17,7 +17,6 @@
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Diagnostics.CSharp;
using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Editor.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
using Microsoft.CodeAnalysis.ErrorLogger;
......@@ -34,7 +33,7 @@ public abstract partial class CSharpSuppressionTests : AbstractSuppressionDiagno
{
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
protected override TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters)
=> TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions);
......
src/EditorFeatures/CSharpTest/EmbeddedLanguages/ValidateRegexStringTests.cs
浏览文件 @ dd09aa5b
......@@ -2,7 +2,6 @@
// 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.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp.EmbeddedLanguages;
......@@ -11,7 +10,6 @@
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions;
using Microsoft.CodeAnalysis.Features.EmbeddedLanguages.RegularExpressions;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
......@@ -25,7 +23,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private OptionsCollection OptionOn()
{
var optionsSet = new OptionsCollection(LanguageNames.CSharp);
optionsSet.Add(new OptionKey2(RegularExpressionsOptions.ReportInvalidRegexPatterns, LanguageNames.CSharp), true);
optionsSet.Add(RegularExpressionsOptions.ReportInvalidRegexPatterns, true);
return optionsSet;
}
......
src/EditorFeatures/CSharpTest/GenerateVariable/GenerateVariableTests.cs
浏览文件 @ dd09aa5b
......@@ -36,17 +36,13 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
private readonly CodeStyleOption2<bool> onWithInfo = new CodeStyleOption2<bool>(true, NotificationOption2.Suggestion);
// specify all options explicitly to override defaults.
private OptionsCollection ImplicitTypingEverywhere() => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
internal IDictionary<OptionKey2, object> OptionSet(OptionKey2 option, object value)
{
var options = new Dictionary<OptionKey2, object>();
options.Add(option, value);
return options;
}
private OptionsCollection ImplicitTypingEverywhere()
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
protected override ImmutableArray<CodeAction> MassageActions(ImmutableArray<CodeAction> actions)
=> FlattenActions(actions);
......
src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests.cs
浏览文件 @ dd09aa5b
......@@ -15,7 +15,6 @@
using Microsoft.CodeAnalysis.ImplementType;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementAbstractClass
......@@ -25,14 +24,16 @@ public partial class ImplementAbstractClassTests : AbstractCSharpDiagnosticProvi
internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
=> (null, new CSharpImplementAbstractClassCodeFixProvider());
private OptionsCollection AllOptionsOff =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection AllOptionsOff
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
internal Task TestAllOptionsOffAsync(
string initialMarkup,
......@@ -42,10 +43,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
ParseOptions parseOptions = null)
{
options = options ?? new OptionsCollection(GetLanguage());
foreach (var (key, value) in AllOptionsOff)
{
options.Add(key, value);
}
options.AddRange(AllOptionsOff);
return TestInRegularAndScriptAsync(
initialMarkup,
......@@ -1239,9 +1237,11 @@ public override int M
throw new System.NotImplementedException();
}
}
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent },
});
}
[WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")]
......@@ -1276,9 +1276,11 @@ public override int M
throw new System.NotImplementedException();
}
}
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent },
});
}
[WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")]
......@@ -1332,9 +1334,11 @@ class T : A
throw new System.NotImplementedException();
}
}
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent },
});
}
[WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")]
......@@ -1369,9 +1373,11 @@ class T : A
throw new System.NotImplementedException();
}
}
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent },
});
}
[WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")]
......@@ -1395,9 +1401,11 @@ class [|T|] : A
class T : A
{
public override int M { get => throw new System.NotImplementedException(); }
}", options: OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.Silent),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.Silent },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
});
}
[WorkItem(581500, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/581500")]
......
src/EditorFeatures/CSharpTest/ImplementAbstractClass/ImplementAbstractClassTests_ThroughMember.cs
浏览文件 @ dd09aa5b
......@@ -11,7 +11,6 @@
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ImplementAbstractClass
......@@ -22,14 +21,16 @@ public sealed class ImplementAbstractClassTests_ThroughMemberTests : AbstractCSh
internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
=> (null, new CSharpImplementAbstractClassCodeFixProvider());
private OptionsCollection AllOptionsOff =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection AllOptionsOff
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
internal Task TestAllOptionsOffAsync(
string initialMarkup,
......@@ -38,10 +39,7 @@ internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProvider
ParseOptions parseOptions = null)
{
options ??= new OptionsCollection(GetLanguage());
foreach (var (key, value) in AllOptionsOff)
{
options.Add(key, value);
}
options.AddRange(AllOptionsOff);
return TestInRegularAndScriptAsync(
initialMarkup,
......
src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs
浏览文件 @ dd09aa5b
......@@ -25,32 +25,38 @@ public partial class ImplementInterfaceTests : AbstractCSharpDiagnosticProviderB
internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
=> (null, new CSharpImplementInterfaceCodeFixProvider());
private OptionsCollection AllOptionsOff =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection AllOptionsOn =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
private OptionsCollection AccessorOptionsOn =>
OptionsSet(
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection AllOptionsOff
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection AllOptionsOn
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection AccessorOptionsOn
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedConstructors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedOperators, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedIndexers, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private static readonly ParseOptions CSharp7_1 = CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_1);
......
src/EditorFeatures/CSharpTest/IntroduceVariable/IntroduceLocalForExpressionTests.cs
浏览文件 @ dd09aa5b
......@@ -8,6 +8,7 @@
using Microsoft.CodeAnalysis.CSharp.CodeStyle;
using Microsoft.CodeAnalysis.CSharp.IntroduceVariable;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
......@@ -326,9 +327,11 @@ void M()
{
var {|Rename:dateTime|} = new DateTime();
}
}", options: OptionsSet(
(CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSuggestionEnforcement),
(CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSuggestionEnforcement)));
}", options: new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, CodeStyleOptions2.TrueWithSuggestionEnforcement },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, CodeStyleOptions2.TrueWithSuggestionEnforcement },
});
}
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceLocalForExpression)]
......
src/EditorFeatures/CSharpTest/MoveToNamespace/MoveToNamespaceTests.cs
浏览文件 @ dd09aa5b
......@@ -33,7 +33,7 @@ protected TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParame
protected override ParseOptions GetScriptOptions() => Options.Script;
protected override string GetLanguage() => LanguageNames.CSharp;
protected internal override string GetLanguage() => LanguageNames.CSharp;
public static IEnumerable<object[]> SupportedKeywords => new[]
{
......
src/EditorFeatures/CSharpTest/SimplifyThisOrMe/SimplifyThisOrMeTests.cs
浏览文件 @ dd09aa5b
......@@ -8,6 +8,7 @@
using Microsoft.CodeAnalysis.CSharp.SimplifyThisOrMe;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
......@@ -419,9 +420,12 @@ void N()
</Project>
</Workspace>";
var options = OptionsSet(
SingleOption(CodeStyleOptions2.QualifyPropertyAccess, false, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Suggestion));
var options =
new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.QualifyPropertyAccess, false, NotificationOption2.Suggestion },
{ CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Suggestion },
};
await TestInRegularAndScriptAsync(
initialMarkup: input,
......
src/EditorFeatures/CSharpTest/SimplifyTypeNames/SimplifyTypeNamesTests.cs
浏览文件 @ dd09aa5b
......@@ -4495,7 +4495,7 @@ public async Task TestCrefIdAtTopLevel()
/// </summary>
class Base
{
}", OptionsSet(), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden);
}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden);
}
[WorkItem(40639, "https://github.com/dotnet/roslyn/issues/40639")]
......@@ -4509,7 +4509,7 @@ public async Task TestCrefIdAtNestedLevel()
class Base
{
public void Foo(string s) { }
}", OptionsSet(), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden);
}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.PreferBuiltInOrFrameworkTypeDiagnosticId, DiagnosticSeverity.Hidden);
}
[Theory, Trait(Traits.Feature, Traits.Features.CodeActionsSimplifyTypeNames)]
......@@ -5848,7 +5848,7 @@ void Goo()
{
var v = nameof([|System|].Int32);
}
}", OptionsSet(), IDEDiagnosticIds.SimplifyMemberAccessDiagnosticId, DiagnosticSeverity.Hidden);
}", new OptionsCollection(GetLanguage()), IDEDiagnosticIds.SimplifyMemberAccessDiagnosticId, DiagnosticSeverity.Hidden);
}
[WorkItem(11380, "https://github.com/dotnet/roslyn/issues/11380")]
......@@ -5869,26 +5869,41 @@ static void Main(string[] args)
private async Task TestWithPredefinedTypeOptionsAsync(string code, string expected, int index = 0)
=> await TestInRegularAndScriptAsync(code, expected, index: index, options: PreferIntrinsicTypeEverywhere);
private OptionsCollection PreferIntrinsicTypeEverywhere => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithError, GetLanguage()));
private OptionsCollection PreferIntrinsicTypeEverywhere
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithError },
};
private OptionsCollection PreferIntrinsicTypeEverywhereAsWarning => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Warning),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithWarning, GetLanguage()));
private OptionsCollection PreferIntrinsicTypeEverywhereAsWarning
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Warning },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.onWithWarning },
};
private OptionsCollection PreferIntrinsicTypeInDeclaration => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.offWithSilent, GetLanguage()));
private OptionsCollection PreferIntrinsicTypeInDeclaration
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, true, NotificationOption2.Error },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, this.offWithSilent },
};
private OptionsCollection PreferIntrinsicTypeInMemberAccess => OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, true, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, this.offWithSilent, GetLanguage()));
private OptionsCollection PreferIntrinsicTypeInMemberAccess
=> new OptionsCollection(GetLanguage())
{
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, true, NotificationOption2.Error },
{ CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, this.offWithSilent },
};
private OptionsCollection PreferImplicitTypeEverywhere => OptionsSet(
SingleOption(CSharpCodeStyleOptions.VarElsewhere, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo),
SingleOption(CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo));
private OptionsCollection PreferImplicitTypeEverywhere
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.VarElsewhere, onWithInfo },
{ CSharpCodeStyleOptions.VarWhenTypeIsApparent, onWithInfo },
{ CSharpCodeStyleOptions.VarForBuiltInTypes, onWithInfo },
};
private readonly CodeStyleOption2<bool> onWithSilent = new CodeStyleOption2<bool>(true, NotificationOption2.Silent);
private readonly CodeStyleOption2<bool> offWithSilent = new CodeStyleOption2<bool>(false, NotificationOption2.Silent);
......
src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForAccessorsRefactoringTests.cs
浏览文件 @ dd09aa5b
......@@ -20,45 +20,61 @@ public class UseExpressionBodyForAccessorsRefactoringTests : AbstractCSharpCodeA
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
=> new UseExpressionBodyCodeRefactoringProvider();
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)));
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None },
};
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)));
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
};
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)));
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
};
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)));
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
public async Task TestUpdatePropertyIfPropertyWantsBlockAndAccessorWantsExpression()
......
src/EditorFeatures/CSharpTest/UseExpressionBody/Refactoring/UseExpressionBodyForPropertiesRefactoringTests.cs
浏览文件 @ dd09aa5b
......@@ -21,45 +21,61 @@ public class UseExpressionBodyForPropertiesRefactoringTests : AbstractCSharpCode
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
=> new UseExpressionBodyCodeRefactoringProvider();
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)));
private OptionsCollection UseExpressionBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None },
};
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)));
private OptionsCollection UseExpressionBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
};
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement));
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.WhenPossible, NotificationOption2.None)));
private OptionsCollection UseBlockBodyForAccessors_ExpressionBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.None },
};
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement));
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
};
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic =>
OptionsSet(
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)),
this.SingleOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, new CodeStyleOption2<ExpressionBodyPreference>(ExpressionBodyPreference.Never, NotificationOption2.None)));
private OptionsCollection UseBlockBodyForAccessors_BlockBodyForProperties_DisabledDiagnostic
=> new OptionsCollection(GetLanguage())
{
{ CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.None },
{ CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.Never, NotificationOption2.None },
};
[Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExpressionBody)]
public async Task TestNotOfferedIfUserPrefersExpressionBodiesAndInBlockBody()
......
src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs
浏览文件 @ dd09aa5b
......@@ -90,7 +90,7 @@ public TestParameters WithIncludeDiagnosticsOutsideSelection(bool includeDiagnos
private const string AutoGeneratedAnalyzerConfigHeader = @"# auto-generated .editorconfig for code style options";
protected abstract string GetLanguage();
protected internal abstract string GetLanguage();
protected ParenthesesOptionsProvider ParenthesesOptionsProvider => new ParenthesesOptionsProvider(this.GetLanguage());
protected abstract ParseOptions GetScriptOptions();
......
src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest_OptionHelpers.cs
浏览文件 @ dd09aa5b
......@@ -4,6 +4,7 @@
#nullable enable
using System;
using Microsoft.CodeAnalysis.CodeStyle;
using Microsoft.CodeAnalysis.Options;
......@@ -33,26 +34,28 @@ internal static (OptionKey2, object) SingleOption<T>(PerLanguageOption2<CodeStyl
=> (new OptionKey2(option, language), codeStyle);
internal OptionsCollection Option<T>(Option2<CodeStyleOption2<T>> option, T enabled, NotificationOption2 notification)
=> OptionsSet(SingleOption(option, enabled, notification));
=> new OptionsCollection(GetLanguage()) { { option, enabled, notification } };
internal OptionsCollection Option<T>(Option2<CodeStyleOption2<T>> option, CodeStyleOption2<T> codeStyle)
=> OptionsSet(SingleOption(option, codeStyle));
=> new OptionsCollection(GetLanguage()) { { option, codeStyle } };
internal OptionsCollection Option<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T enabled, NotificationOption2 notification)
=> OptionsSet(SingleOption(option, enabled, notification));
=> new OptionsCollection(GetLanguage()) { { option, enabled, notification } };
internal OptionsCollection Option<T>(Option2<T> option, T value)
=> OptionsSet(SingleOption(option, value));
=> new OptionsCollection(GetLanguage()) { { option, value } };
internal OptionsCollection Option<T>(PerLanguageOption2<T> option, T value)
=> OptionsSet(SingleOption(option, value));
=> new OptionsCollection(GetLanguage()) { { option, value } };
internal OptionsCollection Option<T>(PerLanguageOption2<CodeStyleOption2<T>> option, CodeStyleOption2<T> codeStyle)
=> OptionsSet(SingleOption(option, codeStyle));
=> new OptionsCollection(GetLanguage()) { { option, codeStyle } };
[Obsolete("Use a strongly-typed overload instead.")]
internal OptionsCollection OptionsSet(OptionKey2 option, object value)
=> OptionsSet((option, value));
[Obsolete("Use a strongly-typed overload instead.")]
internal OptionsCollection OptionsSet(params (OptionKey2 key, object? value)[] options)
=> new OptionsCollection(GetLanguage(), options: options);
}
......
src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/OptionsCollection.cs
浏览文件 @ dd09aa5b
......@@ -4,10 +4,12 @@
#nullable enable
using System;
using System.Collections;
using System.Collections.Generic;
using Microsoft.CodeAnalysis.CodeStyle;
using Microsoft.CodeAnalysis.Options;
using Roslyn.Utilities;
namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
{
......@@ -17,16 +19,20 @@ internal sealed class OptionsCollection : IReadOnlyCollection<KeyValuePair<Optio
private readonly string _languageName;
private readonly string _defaultExtension;
public OptionsCollection(string languageName, params (OptionKey2 key, object? value)[] options)
public OptionsCollection(string languageName)
{
_languageName = languageName;
_defaultExtension = languageName == LanguageNames.CSharp ? "cs" : "vb";
}
[Obsolete("Use a strongly-typed overload instead.")]
public OptionsCollection(string languageName, params (OptionKey2 key, object? value)[] options)
: this(languageName)
{
foreach (var (key, value) in options)
{
Add(key, value);
}
}
public int Count => _options.Count;
......@@ -46,9 +52,18 @@ public void Add<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T value)
public void Add<T>(PerLanguageOption2<CodeStyleOption2<T>> option, T value, NotificationOption2 notification)
=> _options.Add(new OptionKey2(option, _languageName), new CodeStyleOption2<T>(value, notification));
[Obsolete("Use a strongly-typed overload instead.")]
public void Add<T>(OptionKey2 optionKey, T value)
=> _options.Add(optionKey, value);
public void AddRange(OptionsCollection options)
{
foreach (var (key, value) in options)
{
_options.Add(key, value);
}
}
public IEnumerator<KeyValuePair<OptionKey2, object?>> GetEnumerator()
=> _options.GetEnumerator();
......
src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/ParenthesesOptionsProvider.cs
浏览文件 @ dd09aa5b
......@@ -47,28 +47,61 @@ private IEnumerable<PerLanguageOption2<CodeStyleOption2<ParenthesesPreference>>>
=> GetAllExceptOtherParenthesesOptions().Concat(CodeStyleOptions2.OtherParentheses);
internal OptionsCollection IgnoreAllParentheses
=> OptionsSet(GetAllParenthesesOptions().Select(
o => SingleOption(o, IgnorePreference)).ToArray());
{
get
{
var optionsCollection = new OptionsCollection(_language);
foreach (var option in GetAllParenthesesOptions())
{
optionsCollection.Add(option, IgnorePreference);
}
return optionsCollection;
}
}
internal OptionsCollection RemoveAllUnnecessaryParentheses
=> OptionsSet(GetAllParenthesesOptions().Select(
o => SingleOption(o, RemoveIfUnnecessaryPreference)).ToArray());
{
get
{
var optionsCollection = new OptionsCollection(_language);
foreach (var option in GetAllParenthesesOptions())
{
optionsCollection.Add(option, RemoveIfUnnecessaryPreference);
}
return optionsCollection;
}
}
internal OptionsCollection RequireAllParenthesesForClarity
=> OptionsSet(GetAllExceptOtherParenthesesOptions()
.Select(o => SingleOption(o, RequireForPrecedenceClarityPreference))
.Concat(SingleOption(CodeStyleOptions2.OtherParentheses, RemoveIfUnnecessaryPreference)).ToArray());
{
get
{
var optionsCollection = new OptionsCollection(_language);
foreach (var option in GetAllExceptOtherParenthesesOptions())
{
optionsCollection.Add(option, RequireForPrecedenceClarityPreference);
}
optionsCollection.Add(CodeStyleOptions2.OtherParentheses, RemoveIfUnnecessaryPreference);
return optionsCollection;
}
}
private OptionsCollection GetSingleRequireOption(PerLanguageOption2<CodeStyleOption2<ParenthesesPreference>> option)
=> OptionsSet(GetAllParenthesesOptions()
.Where(o => o != option)
.Select(o => SingleOption(o, RemoveIfUnnecessaryPreference))
.Concat(SingleOption(option, RequireForPrecedenceClarityPreference)).ToArray());
private (OptionKey2, object) SingleOption<T>(PerLanguageOption2<CodeStyleOption2<T>> option, CodeStyleOption2<T> codeStyle)
=> (new OptionKey2(option, _language), codeStyle);
internal OptionsCollection OptionsSet(params (OptionKey2 key, object value)[] options)
=> new OptionsCollection(_language, options);
{
var optionsCollection = new OptionsCollection(_language);
foreach (var o in GetAllParenthesesOptions())
{
if (o != option)
{
optionsCollection.Add(o, RemoveIfUnnecessaryPreference);
}
}
optionsCollection.Add(option, RequireForPrecedenceClarityPreference);
return optionsCollection;
}
}
}
src/EditorFeatures/DiagnosticsTestUtilities/NamingStyles/NamingStylesTestOptionSets.cs
浏览文件 @ dd09aa5b
......@@ -31,74 +31,74 @@ internal OptionsCollection MergeStyles(OptionsCollection first, OptionsCollectio
{
var firstPreferences = (NamingStylePreferences)first.First().Value;
var secondPreferences = (NamingStylePreferences)second.First().Value;
return Options(_optionKey, new NamingStylePreferences(
return new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, new NamingStylePreferences(
firstPreferences.SymbolSpecifications.AddRange(secondPreferences.SymbolSpecifications),
firstPreferences.NamingStyles.AddRange(secondPreferences.NamingStyles),
firstPreferences.NamingRules.AddRange(secondPreferences.NamingRules)));
firstPreferences.NamingRules.AddRange(secondPreferences.NamingRules)) } };
}
internal OptionsCollection ClassNamesArePascalCase =>
Options(_optionKey, ClassNamesArePascalCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ClassNamesArePascalCaseOption() } };
internal OptionsCollection FieldNamesAreCamelCase =>
Options(_optionKey, FieldNamesAreCamelCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseOption() } };
internal OptionsCollection FieldNamesAreCamelCaseWithUnderscorePrefix =>
Options(_optionKey, FieldNamesAreCamelCaseWithUnderscorePrefixOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithUnderscorePrefixOption() } };
internal OptionsCollection FieldNamesAreCamelCaseWithFieldUnderscorePrefix =>
Options(_optionKey, FieldNamesAreCamelCaseWithFieldUnderscorePrefixOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithFieldUnderscorePrefixOption() } };
internal OptionsCollection FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffix =>
Options(_optionKey, FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffixOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, FieldNamesAreCamelCaseWithFieldUnderscorePrefixAndUnderscoreEndSuffixOption() } };
internal OptionsCollection MethodNamesArePascalCase =>
Options(_optionKey, MethodNamesArePascalCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesArePascalCaseOption() } };
internal OptionsCollection MethodNamesAreCamelCase =>
Options(_optionKey, MethodNamesAreCamelCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesAreCamelCaseOption() } };
internal OptionsCollection ParameterNamesAreCamelCase =>
Options(_optionKey, ParameterNamesAreCamelCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseOption() } };
internal OptionsCollection ParameterNamesAreCamelCaseWithPUnderscorePrefix =>
Options(_optionKey, ParameterNamesAreCamelCaseWithPUnderscorePrefixOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseWithPUnderscorePrefixOption() } };
internal OptionsCollection ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffix =>
Options(_optionKey, ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffixOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ParameterNamesAreCamelCaseWithPUnderscorePrefixAndUnderscoreEndSuffixOption() } };
internal OptionsCollection LocalNamesAreCamelCase =>
Options(_optionKey, LocalNamesAreCamelCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalNamesAreCamelCaseOption() } };
internal OptionsCollection LocalFunctionNamesAreCamelCase =>
Options(_optionKey, LocalFunctionNamesAreCamelCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalFunctionNamesAreCamelCaseOption() } };
internal OptionsCollection PropertyNamesArePascalCase =>
Options(_optionKey, PropertyNamesArePascalCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, PropertyNamesArePascalCaseOption() } };
internal OptionsCollection InterfaceNamesStartWithI =>
Options(_optionKey, InterfaceNamesStartWithIOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, InterfaceNamesStartWithIOption() } };
internal OptionsCollection TypeParameterNamesStartWithT =>
Options(_optionKey, TypeParameterNamesStartWithTOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, TypeParameterNamesStartWithTOption() } };
internal OptionsCollection ConstantsAreUpperCase =>
Options(_optionKey, ConstantsAreUpperCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, ConstantsAreUpperCaseOption() } };
internal OptionsCollection LocalsAreCamelCaseConstantsAreUpperCase =>
Options(_optionKey, LocalsAreCamelCaseConstantsAreUpperCaseOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, LocalsAreCamelCaseConstantsAreUpperCaseOption() } };
internal OptionsCollection AsyncFunctionNamesEndWithAsync =>
Options(_optionKey, AsyncFunctionNamesEndWithAsyncOption());
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, AsyncFunctionNamesEndWithAsyncOption() } };
internal OptionsCollection MethodNamesWithAccessibilityArePascalCase(ImmutableArray<Accessibility> accessibilities) =>
Options(_optionKey, MethodNamesArePascalCaseOption(accessibilities));
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, MethodNamesArePascalCaseOption(accessibilities) } };
internal OptionsCollection SymbolKindsArePascalCase(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind> symbolKinds) =>
Options(_optionKey, SymbolKindsArePascalCaseOption(symbolKinds));
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, SymbolKindsArePascalCaseOption(symbolKinds) } };
internal OptionsCollection SymbolKindsArePascalCaseEmpty() =>
Options(_optionKey, SymbolKindsArePascalCaseOption(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind>.Empty));
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, SymbolKindsArePascalCaseOption(ImmutableArray<SymbolSpecification.SymbolKindOrTypeKind>.Empty) } };
internal OptionsCollection SymbolKindsArePascalCase(object symbolOrTypeKind) =>
SymbolKindsArePascalCase(ImmutableArray.Create(ToSymbolKindOrTypeKind(symbolOrTypeKind)));
......@@ -122,13 +122,7 @@ internal static SymbolSpecification.SymbolKindOrTypeKind ToSymbolKindOrTypeKind(
}
internal OptionsCollection AccessibilitiesArePascalCase(ImmutableArray<Accessibility> accessibilities) =>
Options(_optionKey, AccessibilitiesArePascalCaseOption(accessibilities));
private OptionsCollection Options(OptionKey2 option, object value)
=> Options(new[] { (option, value) });
private OptionsCollection Options(params (OptionKey2 key, object value)[] options)
=> new OptionsCollection(_languageName, options);
new OptionsCollection(_languageName) { { NamingStyleOptions.NamingPreferences, AccessibilitiesArePascalCaseOption(accessibilities) } };
private static NamingStylePreferences ClassNamesArePascalCaseOption()
{
......
src/EditorFeatures/Test/LinkedFiles/LinkedFileDiffMergingEditorTests.cs
浏览文件 @ dd09aa5b
......@@ -10,7 +10,6 @@
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.UnitTests.LinkedFiles
......@@ -26,7 +25,7 @@ public partial class LinkedFileDiffMergingEditorTests : AbstractCodeActionTest
</Project>
</Workspace>";
protected override string GetLanguage()
protected internal override string GetLanguage()
=> LanguageNames.CSharp;
protected override CodeRefactoringProvider CreateCodeRefactoringProvider(Workspace workspace, TestParameters parameters)
......
src/EditorFeatures/VisualBasicTest/CodeRefactorings/AddMissingImports/VisualBasicAddMissingImportsRefactoringProviderTests.vb
浏览文件 @ dd09aa5b
......@@ -4,6 +4,7 @@
Imports Microsoft.CodeAnalysis.CodeRefactorings
Imports Microsoft.CodeAnalysis.Editing
Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
Imports Microsoft.CodeAnalysis.PasteTracking
......@@ -44,9 +45,10 @@ Namespace Microsoft.CodeAnalysis.AddMissingImports
initialMarkup As String, expectedMarkup As String,
placeSystemNamespaceFirst As Boolean, separateImportDirectiveGroups As Boolean) As Task
Dim options = OptionsSet(
SingleOption(GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst),
SingleOption(GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups))
Dim options = New OptionsCollection(GetLanguage()) From {
{GenerationOptions.PlaceSystemNamespaceFirst, placeSystemNamespaceFirst},
{GenerationOptions.SeparateImportDirectiveGroups, separateImportDirectiveGroups}
}
Return TestInRegularAndScriptAsync(initialMarkup, expectedMarkup, options:=options)
End Function
......
src/EditorFeatures/VisualBasicTest/Diagnostics/PreferFrameworkType/PreferFrameworkTypeTests.vb
浏览文件 @ dd09aa5b
......@@ -25,33 +25,37 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.Prefer
Private ReadOnly Property NoFrameworkType As OptionsCollection
Get
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo, GetLanguage()))
Return New OptionsCollection(GetLanguage()) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Suggestion},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo}
}
End Get
End Property
Private ReadOnly Property FrameworkTypeEverywhere As OptionsCollection
Get
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithInfo, GetLanguage()))
Return New OptionsCollection(GetLanguage()) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithInfo}
}
End Get
End Property
Private ReadOnly Property FrameworkTypeInDeclaration As OptionsCollection
Get
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo, GetLanguage()))
Return New OptionsCollection(GetLanguage()) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, False, NotificationOption2.Suggestion},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithInfo}
}
End Get
End Property
Private ReadOnly Property FrameworkTypeInMemberAccess As OptionsCollection
Get
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, False, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.onWithInfo, GetLanguage()))
Return New OptionsCollection(GetLanguage()) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, False, NotificationOption2.Suggestion},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.onWithInfo}
}
End Get
End Property
......
src/EditorFeatures/VisualBasicTest/EmbeddedLanguages/ValidateRegexStringTests.vb
浏览文件 @ dd09aa5b
......@@ -8,7 +8,6 @@ Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
Imports Microsoft.CodeAnalysis.EmbeddedLanguages.RegularExpressions
Imports Microsoft.CodeAnalysis.Features.EmbeddedLanguages.RegularExpressions
Imports Microsoft.CodeAnalysis.Options
Imports Microsoft.CodeAnalysis.VisualBasic.Features.EmbeddedLanguages
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EmbeddedLanguages
......@@ -21,7 +20,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.EmbeddedLanguages
Private Function OptionOn() As OptionsCollection
Dim values = New OptionsCollection(LanguageNames.VisualBasic)
values.Add(New OptionKey2(RegularExpressionsOptions.ReportInvalidRegexPatterns, LanguageNames.VisualBasic), True)
values.Add(RegularExpressionsOptions.ReportInvalidRegexPatterns, True)
Return values
End Function
......
src/EditorFeatures/VisualBasicTest/GenerateConstructorFromMembers/GenerateConstructorFromMembersTests.vb
浏览文件 @ dd09aa5b
......@@ -6,7 +6,6 @@ Imports Microsoft.CodeAnalysis.CodeRefactorings
Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
Imports Microsoft.CodeAnalysis.GenerateConstructorFromMembers
Imports Microsoft.CodeAnalysis.Options
Imports Microsoft.CodeAnalysis.PickMembers
Imports Microsoft.CodeAnalysis.VisualBasic.GenerateConstructorFromMembers
......@@ -368,7 +367,7 @@ End Class", chosenSymbols:={"i"})
<Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructorFromMembers)>
Public Async Function TestWithDialog1WithNullCheck() As Task
Dim options = New OptionsCollection(LanguageNames.VisualBasic)
options.Add(New OptionKey2(GenerateConstructorFromMembersOptions.AddNullChecks, language:=LanguageNames.VisualBasic), True)
options.Add(GenerateConstructorFromMembersOptions.AddNullChecks, True)
Dim parameters = New TestParameters()
parameters = parameters.WithOptions(options)
......
src/EditorFeatures/VisualBasicTest/SimplifyThisOrMe/SimplifyThisOrMeTests.vb
浏览文件 @ dd09aa5b
......@@ -5,13 +5,9 @@
Imports Microsoft.CodeAnalysis.CodeFixes
Imports Microsoft.CodeAnalysis.CodeStyle
Imports Microsoft.CodeAnalysis.Diagnostics
Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
Imports Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions
Imports Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics
Imports Microsoft.CodeAnalysis.Options
Imports Microsoft.CodeAnalysis.VisualBasic.CodeFixes.SimplifyTypeNames
Imports Microsoft.CodeAnalysis.VisualBasic.SimplifyThisOrMe
Imports Microsoft.CodeAnalysis.VisualBasic.SimplifyTypeNames
Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SimplifyThisOrMe
Partial Public Class SimplifyThisOrMeTests
......@@ -66,7 +62,7 @@ End Class")
Public Async Function TestAppropriateDiagnosticOnMissingQualifier() As Task
Await TestDiagnosticInfoAsync(
"Class C : Property SomeProperty As Integer : Sub M() : [|Me|].SomeProperty = 1 : End Sub : End Class",
options:=OptionsSet(SingleOption(CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Error)),
options:=New OptionsCollection(GetLanguage()) From {{CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Error}},
diagnosticId:=IDEDiagnosticIds.RemoveQualificationDiagnosticId,
diagnosticSeverity:=DiagnosticSeverity.Error)
End Function
......@@ -344,9 +340,10 @@ End Class]]>
</Project>
</Workspace>.ToString()
Dim options = OptionsSet(
SingleOption(CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Suggestion),
SingleOption(CodeStyleOptions2.QualifyFieldAccess, True, NotificationOption2.Suggestion))
Dim options = New OptionsCollection(GetLanguage()) From {
{CodeStyleOptions2.QualifyPropertyAccess, False, NotificationOption2.Suggestion},
{CodeStyleOptions2.QualifyFieldAccess, True, NotificationOption2.Suggestion}
}
Await TestInRegularAndScriptAsync(
initialMarkup:=input,
expectedMarkup:=expected,
......
src/EditorFeatures/VisualBasicTest/SimplifyTypeNames/SimplifyTypeNamesTests.vb
浏览文件 @ dd09aa5b
......@@ -24,25 +24,28 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.SimplifyTypeNames
Private Function PreferIntrinsicPredefinedTypeEverywhere() As OptionsCollection
Dim language = GetLanguage()
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithError, language))
Return New OptionsCollection(language) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.onWithError}
}
End Function
Private Function PreferIntrinsicPredefinedTypeInDeclaration() As OptionsCollection
Dim language = GetLanguage()
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithSilent, language))
Return New OptionsCollection(language) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, True, NotificationOption2.Error},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, Me.offWithSilent}
}
End Function
Private Function PreferIntrinsicTypeInMemberAccess() As OptionsCollection
Dim language = GetLanguage()
Return OptionsSet(
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, True, NotificationOption2.Error),
SingleOption(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.offWithSilent, language))
Return New OptionsCollection(language) From {
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess, True, NotificationOption2.Error},
{CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInDeclaration, Me.offWithSilent}
}
End Function
Private ReadOnly onWithError As New CodeStyleOption2(Of Boolean)(True, NotificationOption2.Error)
......
src/VisualStudio/CSharp/Test/EventHookup/EventHookupCommandHandlerTests.cs
浏览文件 @ dd09aa5b
......@@ -1023,6 +1023,6 @@ private void C_MyEvent()
}
private OptionsCollection QualifyMethodAccessWithNotification(NotificationOption2 notification)
=> new OptionsCollection(LanguageNames.CSharp) { { new OptionKey2(CodeStyleOptions2.QualifyMethodAccess, LanguageNames.CSharp), new CodeStyleOption2<bool>(true, notification) } };
=> new OptionsCollection(LanguageNames.CSharp) { { CodeStyleOptions2.QualifyMethodAccess, true, notification } };
}
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或