diff --git a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems index 11626e4ceb326..2ad9d0c216154 100644 --- a/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems +++ b/src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems @@ -45,9 +45,22 @@ + + + + + + + + + + + + + diff --git a/src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateConstructor/CSharpGenerateConstructorService.cs similarity index 100% rename from src/Features/CSharp/Portable/GenerateConstructor/CSharpGenerateConstructorService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateConstructor/CSharpGenerateConstructorService.cs diff --git a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.cs similarity index 88% rename from src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.cs index ec7933d35312d..e2b20ae46539f 100644 --- a/src/Features/CSharp/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.cs @@ -34,14 +34,10 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateConstructor; /// [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateConstructor), Shared] [ExtensionOrder(After = PredefinedCodeFixProviderNames.FullyQualify)] -internal class GenerateConstructorCodeFixProvider : AbstractGenerateMemberCodeFixProvider +[method: ImportingConstructor] +[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] +internal sealed class GenerateConstructorCodeFixProvider() : AbstractGenerateMemberCodeFixProvider { - [ImportingConstructor] - [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] - public GenerateConstructorCodeFixProvider() - { - } - public override ImmutableArray FixableDiagnosticIds => GenerateConstructorDiagnosticIds.AllDiagnosticIds; protected override Task> GetCodeActionsAsync( diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateEnumMember/CSharpGenerateEnumMemberService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/CSharpGenerateEnumMemberService.cs similarity index 91% rename from src/Features/CSharp/Portable/GenerateMember/GenerateEnumMember/CSharpGenerateEnumMemberService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/CSharpGenerateEnumMemberService.cs index 10d3a4fd5598c..25785bb31454f 100644 --- a/src/Features/CSharp/Portable/GenerateMember/GenerateEnumMember/CSharpGenerateEnumMemberService.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/CSharpGenerateEnumMemberService.cs @@ -14,15 +14,11 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateEnumMember; [ExportLanguageService(typeof(IGenerateEnumMemberService), LanguageNames.CSharp), Shared] -internal partial class CSharpGenerateEnumMemberService : +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed partial class CSharpGenerateEnumMemberService() : AbstractGenerateEnumMemberService { - [ImportingConstructor] - [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public CSharpGenerateEnumMemberService() - { - } - protected override bool IsIdentifierNameGeneration(SyntaxNode node) => node is IdentifierNameSyntax; diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs similarity index 83% rename from src/Features/CSharp/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs index 9c8da121dba61..0c6119fbe7905 100644 --- a/src/Features/CSharp/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.cs @@ -19,17 +19,13 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateEnumMember; [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateEnumMember), Shared] [ExtensionOrder(After = PredefinedCodeFixProviderNames.GenerateConstructor)] -internal class GenerateEnumMemberCodeFixProvider : AbstractGenerateMemberCodeFixProvider +[method: ImportingConstructor] +[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] +internal sealed class GenerateEnumMemberCodeFixProvider() : AbstractGenerateMemberCodeFixProvider { private const string CS0117 = nameof(CS0117); // error CS0117: 'Color' does not contain a definition for 'Red' private const string CS1061 = nameof(CS1061); // error CS1061: 'Color' does not contain a definition for 'Red' and no accessible extension method 'Red' accepting a first argument of type 'Color' could be found - [ImportingConstructor] - [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] - public GenerateEnumMemberCodeFixProvider() - { - } - public override ImmutableArray FixableDiagnosticIds { get; } = [CS0117, CS1061]; diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs similarity index 87% rename from src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs index 4bfacf947f333..af47c46976f2f 100644 --- a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateConversionCodeFixProvider.cs @@ -20,17 +20,13 @@ namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateMethod; [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateConversion), Shared] [ExtensionOrder(After = PredefinedCodeFixProviderNames.GenerateEnumMember)] -internal class GenerateConversionCodeFixProvider : AbstractGenerateMemberCodeFixProvider +[method: ImportingConstructor] +[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] +internal sealed class GenerateConversionCodeFixProvider() : AbstractGenerateMemberCodeFixProvider { private const string CS0029 = nameof(CS0029); // error CS0029: Cannot implicitly convert type 'type' to 'type' private const string CS0030 = nameof(CS0030); // error CS0030: Cannot convert type 'type' to 'type' - [ImportingConstructor] - [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] - public GenerateConversionCodeFixProvider() - { - } - public override ImmutableArray FixableDiagnosticIds { get { return [CS0029, CS0030]; } diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs similarity index 100% rename from src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateDeconstructMethodCodeFixProvider.cs diff --git a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs similarity index 92% rename from src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs index 5c30027be904c..ebdc100c1d1a4 100644 --- a/src/Features/CSharp/Portable/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateMethod/GenerateMethodCodeFixProvider.cs @@ -44,14 +44,10 @@ internal static class GenerateMethodDiagnosticIds [ExtensionOrder(After = PredefinedCodeFixProviderNames.GenerateEnumMember)] [ExtensionOrder(Before = PredefinedCodeFixProviderNames.PopulateSwitch)] [ExtensionOrder(Before = PredefinedCodeFixProviderNames.GenerateVariable)] -internal sealed class GenerateMethodCodeFixProvider : AbstractGenerateMemberCodeFixProvider +[method: ImportingConstructor] +[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] +internal sealed class GenerateMethodCodeFixProvider() : AbstractGenerateMemberCodeFixProvider { - [ImportingConstructor] - [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] - public GenerateMethodCodeFixProvider() - { - } - public override ImmutableArray FixableDiagnosticIds { get; } = GenerateMethodDiagnosticIds.FixableDiagnosticIds; diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpCommonGenerationServiceMethods.cs b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpCommonGenerationServiceMethods.cs similarity index 100% rename from src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpCommonGenerationServiceMethods.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpCommonGenerationServiceMethods.cs diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateConversionService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateConversionService.cs similarity index 95% rename from src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateConversionService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateConversionService.cs index 674f5b2dab83b..084ccf0323348 100644 --- a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateConversionService.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateConversionService.cs @@ -20,15 +20,11 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateParameterizedMember; [ExportLanguageService(typeof(IGenerateConversionService), LanguageNames.CSharp), Shared] -internal partial class CSharpGenerateConversionService : +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed partial class CSharpGenerateConversionService() : AbstractGenerateConversionService { - [ImportingConstructor] - [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public CSharpGenerateConversionService() - { - } - protected override bool IsImplicitConversionGeneration(SyntaxNode node) { return node is ExpressionSyntax && @@ -220,8 +216,8 @@ private static IMethodSymbol GenerateMethodSymbol( } protected override string GetImplicitConversionDisplayText(AbstractGenerateParameterizedMemberService.State state) - => string.Format(CSharpFeaturesResources.Generate_implicit_conversion_operator_in_0, state.TypeToGenerateIn.Name); + => string.Format(CodeFixesResources.Generate_implicit_conversion_operator_in_0, state.TypeToGenerateIn.Name); protected override string GetExplicitConversionDisplayText(AbstractGenerateParameterizedMemberService.State state) - => string.Format(CSharpFeaturesResources.Generate_explicit_conversion_operator_in_0, state.TypeToGenerateIn.Name); + => string.Format(CodeFixesResources.Generate_explicit_conversion_operator_in_0, state.TypeToGenerateIn.Name); } diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs similarity index 94% rename from src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs index 92cb73480134c..862f7db6e3f54 100644 --- a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateDeconstructMethodService.cs @@ -20,15 +20,11 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateMethod; [ExportLanguageService(typeof(IGenerateDeconstructMemberService), LanguageNames.CSharp), Shared] -internal sealed class CSharpGenerateDeconstructMethodService : +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed class CSharpGenerateDeconstructMethodService() : AbstractGenerateDeconstructMethodService { - [ImportingConstructor] - [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public CSharpGenerateDeconstructMethodService() - { - } - protected override bool ContainingTypesOrSelfHasUnsafeKeyword(INamedTypeSymbol containingType) => containingType.ContainingTypesOrSelfHasUnsafeKeyword(); diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateMethodService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateMethodService.cs similarity index 97% rename from src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateMethodService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateMethodService.cs index 9fa97b3e47cb2..f6986582d93d0 100644 --- a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateMethodService.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateMethodService.cs @@ -21,15 +21,11 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateMember.GenerateMethod; [ExportLanguageService(typeof(IGenerateParameterizedMemberService), LanguageNames.CSharp), Shared] -internal sealed class CSharpGenerateMethodService : +[method: ImportingConstructor] +[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] +internal sealed class CSharpGenerateMethodService() : AbstractGenerateMethodService { - [ImportingConstructor] - [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] - public CSharpGenerateMethodService() - { - } - protected override bool IsExplicitInterfaceGeneration(SyntaxNode node) => node is MethodDeclarationSyntax; diff --git a/src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateParameterizedMemberService.cs b/src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateParameterizedMemberService.cs similarity index 100% rename from src/Features/CSharp/Portable/GenerateMember/GenerateParameterizedMember/CSharpGenerateParameterizedMemberService.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateParameterizedMember/CSharpGenerateParameterizedMemberService.cs diff --git a/src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs b/src/Analyzers/CSharp/CodeFixes/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs similarity index 88% rename from src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs rename to src/Analyzers/CSharp/CodeFixes/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs index 5c496ede5cd18..1d263364de048 100644 --- a/src/Features/CSharp/Portable/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs +++ b/src/Analyzers/CSharp/CodeFixes/GenerateVariable/CSharpGenerateVariableCodeFixProvider.cs @@ -22,7 +22,9 @@ namespace Microsoft.CodeAnalysis.CSharp.GenerateVariable; [ExportCodeFixProvider(LanguageNames.CSharp, Name = PredefinedCodeFixProviderNames.GenerateVariable), Shared] [ExtensionOrder(After = PredefinedCodeFixProviderNames.GenerateMethod)] -internal class CSharpGenerateVariableCodeFixProvider : AbstractGenerateMemberCodeFixProvider +[method: ImportingConstructor] +[method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] +internal sealed class CSharpGenerateVariableCodeFixProvider() : AbstractGenerateMemberCodeFixProvider { private const string CS1061 = nameof(CS1061); // error CS1061: 'C' does not contain a definition for 'Goo' and no extension method 'Goo' accepting a first argument of type 'C' could be found private const string CS0103 = nameof(CS0103); // error CS0103: The name 'Goo' does not exist in the current context @@ -32,12 +34,6 @@ internal class CSharpGenerateVariableCodeFixProvider : AbstractGenerateMemberCod private const string CS0120 = nameof(CS0120); // error CS0120: An object reference is required for the non-static field, method, or property 'A' private const string CS0118 = nameof(CS0118); // error CS0118: 'C' is a type but is used like a variable - [ImportingConstructor] - [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")] - public CSharpGenerateVariableCodeFixProvider() - { - } - public override ImmutableArray FixableDiagnosticIds => [CS1061, CS0103, CS0117, CS0539, CS0246, CS0120, CS0118]; diff --git a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems index 16526869a0819..43978f21d34d9 100644 --- a/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems +++ b/src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems @@ -33,7 +33,12 @@ + + + + + diff --git a/src/Features/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs b/src/Analyzers/CSharp/Tests/GenerateConstructor/GenerateConstructorTests.cs similarity index 99% rename from src/Features/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs rename to src/Analyzers/CSharp/Tests/GenerateConstructor/GenerateConstructorTests.cs index 3fa80c6c96c1b..2d3bdb24c3f20 100644 --- a/src/Features/CSharpTest/GenerateConstructor/GenerateConstructorTests.cs +++ b/src/Analyzers/CSharp/Tests/GenerateConstructor/GenerateConstructorTests.cs @@ -19,13 +19,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateConstructor; [Trait(Traits.Feature, Traits.Features.CodeActionsGenerateConstructor)] -public class GenerateConstructorTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor +public sealed class GenerateConstructorTests(ITestOutputHelper logger) + : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger) { - public GenerateConstructorTests(ITestOutputHelper logger) - : base(logger) - { - } - internal override (DiagnosticAnalyzer?, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new GenerateConstructorCodeFixProvider()); @@ -2788,74 +2784,6 @@ class D """); } - [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530003")] - public async Task TestAttributesWithAllValidParameters() - { - await TestInRegularAndScriptAsync( - """ - using System; - - enum A - { - A1 - } - - [AttributeUsage(AttributeTargets.Class)] - class MyAttrAttribute : Attribute - { - } - - [|[MyAttrAttribute(new int[] { 1, 2, 3 }, A.A1, true, (byte)1, 'a', (short)12, (int)1, (long)5L, 5D, 3.5F, "hello")]|] - class D - { - } - """, - """ - using System; - - enum A - { - A1 - } - - [AttributeUsage(AttributeTargets.Class)] - class MyAttrAttribute : Attribute - { - private int[] ints; - private A a1; - private bool v1; - private byte v2; - private char v3; - private short v4; - private int v5; - private long v6; - private double v7; - private float v8; - private string v9; - - public MyAttrAttribute(int[] ints, A a1, bool v1, byte v2, char v3, short v4, int v5, long v6, double v7, float v8, string v9) - { - this.ints = ints; - this.a1 = a1; - this.v1 = v1; - this.v2 = v2; - this.v3 = v3; - this.v4 = v4; - this.v5 = v5; - this.v6 = v6; - this.v7 = v7; - this.v8 = v8; - this.v9 = v9; - } - } - - [MyAttrAttribute(new int[] { 1, 2, 3 }, A.A1, true, (byte)1, 'a', (short)12, (int)1, (long)5L, 5D, 3.5F, "hello")] - class D - { - } - """); - } - [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530003")] public async Task TestAttributesWithDelegation() { @@ -4575,39 +4503,6 @@ public A(int* a, int b, int c) : this(a, b) { } """); } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] - public async Task TestGenerateNameFromTypeArgument() - { - await TestInRegularAndScriptAsync( -""" - using System.Collections.Generic; - - class Frog { } - - class C - { - C M() => new [||]C(new List()); - } - """, -""" - using System.Collections.Generic; - - class Frog { } - - class C - { - private List frogs; - - public C(List frogs) - { - this.frogs = frogs; - } - - C M() => new C(new List()); - } - """); - } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] public async Task TestDoNotGenerateNameFromTypeArgumentIfNotEnumerable() { @@ -4643,39 +4538,6 @@ C M() """); } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] - public async Task TestGenerateNameFromTypeArgumentForErrorType() - { - await TestInRegularAndScriptAsync( -""" - using System.Collections.Generic; - - class Frog { } - - class C - { - C M() => new [||]C(new List<>()); - } - """, -""" - using System.Collections.Generic; - - class Frog { } - - class C - { - private List ts; - - public C(List ts) - { - this.ts = ts; - } - - C M() => new C(new List<>()); - } - """); - } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] public async Task TestGenerateNameFromTypeArgumentForTupleType() { @@ -4709,43 +4571,6 @@ public C(List<(int, string)> list) """); } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] - public async Task TestGenerateNameFromTypeArgumentInNamespace() - { - await TestInRegularAndScriptAsync( -""" - using System.Collections.Generic; - - namespace N { - class Frog { } - - class C - { - C M() => new [||]C(new List()); - } - } - """, -""" - using System.Collections.Generic; - - namespace N { - class Frog { } - - class C - { - private List frogs; - - public C(List frogs) - { - this.frogs = frogs; - } - - C M() => new C(new List()); - } - } - """); - } - [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47928")] public async Task TestGenerateConstructorFromImplicitObjectCreation() { @@ -5144,4 +4969,179 @@ public static void Test() } """); } + +#if !CODE_STYLE + + [Fact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/530003")] + public async Task TestAttributesWithAllValidParameters() + { + await TestInRegularAndScriptAsync( + """ + using System; + + enum A + { + A1 + } + + [AttributeUsage(AttributeTargets.Class)] + class MyAttrAttribute : Attribute + { + } + + [|[MyAttrAttribute(new int[] { 1, 2, 3 }, A.A1, true, (byte)1, 'a', (short)12, (int)1, (long)5L, 5D, 3.5F, "hello")]|] + class D + { + } + """, + """ + using System; + + enum A + { + A1 + } + + [AttributeUsage(AttributeTargets.Class)] + class MyAttrAttribute : Attribute + { + private int[] ints; + private A a1; + private bool v1; + private byte v2; + private char v3; + private short v4; + private int v5; + private long v6; + private double v7; + private float v8; + private string v9; + + public MyAttrAttribute(int[] ints, A a1, bool v1, byte v2, char v3, short v4, int v5, long v6, double v7, float v8, string v9) + { + this.ints = ints; + this.a1 = a1; + this.v1 = v1; + this.v2 = v2; + this.v3 = v3; + this.v4 = v4; + this.v5 = v5; + this.v6 = v6; + this.v7 = v7; + this.v8 = v8; + this.v9 = v9; + } + } + + [MyAttrAttribute(new int[] { 1, 2, 3 }, A.A1, true, (byte)1, 'a', (short)12, (int)1, (long)5L, 5D, 3.5F, "hello")] + class D + { + } + """); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] + public async Task TestGenerateNameFromTypeArgument() + { + await TestInRegularAndScriptAsync( +""" + using System.Collections.Generic; + + class Frog { } + + class C + { + C M() => new [||]C(new List()); + } + """, +""" + using System.Collections.Generic; + + class Frog { } + + class C + { + private List frogs; + + public C(List frogs) + { + this.frogs = frogs; + } + + C M() => new C(new List()); + } + """); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] + public async Task TestGenerateNameFromTypeArgumentForErrorType() + { + await TestInRegularAndScriptAsync( +""" + using System.Collections.Generic; + + class Frog { } + + class C + { + C M() => new [||]C(new List<>()); + } + """, +""" + using System.Collections.Generic; + + class Frog { } + + class C + { + private List ts; + + public C(List ts) + { + this.ts = ts; + } + + C M() => new C(new List<>()); + } + """); + } + + [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44708")] + public async Task TestGenerateNameFromTypeArgumentInNamespace() + { + await TestInRegularAndScriptAsync( +""" + using System.Collections.Generic; + + namespace N { + class Frog { } + + class C + { + C M() => new [||]C(new List()); + } + } + """, +""" + using System.Collections.Generic; + + namespace N { + class Frog { } + + class C + { + private List frogs; + + public C(List frogs) + { + this.frogs = frogs; + } + + C M() => new C(new List()); + } + } + """); + } + +#endif } diff --git a/src/Features/CSharpTest/GenerateEnumMember/GenerateEnumMemberTests.cs b/src/Analyzers/CSharp/Tests/GenerateEnumMember/GenerateEnumMemberTests.cs similarity index 99% rename from src/Features/CSharpTest/GenerateEnumMember/GenerateEnumMemberTests.cs rename to src/Analyzers/CSharp/Tests/GenerateEnumMember/GenerateEnumMemberTests.cs index 8434f60dd792c..ef4531bb9b3f2 100644 --- a/src/Features/CSharpTest/GenerateEnumMember/GenerateEnumMemberTests.cs +++ b/src/Analyzers/CSharp/Tests/GenerateEnumMember/GenerateEnumMemberTests.cs @@ -16,13 +16,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.GenerateEnumMember; [Trait(Traits.Feature, Traits.Features.CodeActionsGenerateEnumMember)] -public class GenerateEnumMemberTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor +public sealed class GenerateEnumMemberTests(ITestOutputHelper logger) + : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger) { - public GenerateEnumMemberTests(ITestOutputHelper logger) - : base(logger) - { - } - internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new GenerateEnumMemberCodeFixProvider()); diff --git a/src/Features/CSharpTest/GenerateMethod/GenerateConversionTests.cs b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateConversionTests.cs similarity index 96% rename from src/Features/CSharpTest/GenerateMethod/GenerateConversionTests.cs rename to src/Analyzers/CSharp/Tests/GenerateMethod/GenerateConversionTests.cs index de2ec8843bf82..65a5634332887 100644 --- a/src/Features/CSharpTest/GenerateMethod/GenerateConversionTests.cs +++ b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateConversionTests.cs @@ -17,13 +17,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.GenerateMethod; [Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)] -public class GenerateConversionTest : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor +public sealed class GenerateConversionTests(ITestOutputHelper logger) + : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger) { - public GenerateConversionTest(ITestOutputHelper logger) - : base(logger) - { - } - internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new GenerateConversionCodeFixProvider()); diff --git a/src/Features/CSharpTest/GenerateMethod/GenerateDeconstructMethodTests.cs b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateDeconstructMethodTests.cs similarity index 97% rename from src/Features/CSharpTest/GenerateMethod/GenerateDeconstructMethodTests.cs rename to src/Analyzers/CSharp/Tests/GenerateMethod/GenerateDeconstructMethodTests.cs index 0462179ffd750..ea95b0f287d11 100644 --- a/src/Features/CSharpTest/GenerateMethod/GenerateDeconstructMethodTests.cs +++ b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateDeconstructMethodTests.cs @@ -16,13 +16,9 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.GenerateDeconstructMethod; [Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)] -public class GenerateDeconstructMethodTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor +public sealed class GenerateDeconstructMethodTests(ITestOutputHelper logger) + : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor(logger) { - public GenerateDeconstructMethodTests(ITestOutputHelper logger) - : base(logger) - { - } - internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace) => (null, new GenerateDeconstructMethodCodeFixProvider()); diff --git a/src/Features/CSharpTest/GenerateMethod/GenerateMethodTests.cs b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateMethodTests.cs similarity index 99% rename from src/Features/CSharpTest/GenerateMethod/GenerateMethodTests.cs rename to src/Analyzers/CSharp/Tests/GenerateMethod/GenerateMethodTests.cs index 8ca11d1c34efc..11377189c98f5 100644 --- a/src/Features/CSharpTest/GenerateMethod/GenerateMethodTests.cs +++ b/src/Analyzers/CSharp/Tests/GenerateMethod/GenerateMethodTests.cs @@ -4,6 +4,7 @@ using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeFixes; +using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.CodeFixes.GenerateMethod; using Microsoft.CodeAnalysis.CSharp.CodeStyle; using Microsoft.CodeAnalysis.CSharp.Test.Utilities; @@ -5300,7 +5301,7 @@ internal static void Test(global::Outer.Inner inner) } } """, -new TestParameters(Options.Regular)); +new TestParameters(new CSharpParseOptions(kind: SourceCodeKind.Regular))); } [Theory] diff --git a/src/Analyzers/Core/CodeFixes/CodeFixes.projitems b/src/Analyzers/Core/CodeFixes/CodeFixes.projitems index 82719fc7b956a..6160e528c4ffd 100644 --- a/src/Analyzers/Core/CodeFixes/CodeFixes.projitems +++ b/src/Analyzers/Core/CodeFixes/CodeFixes.projitems @@ -39,6 +39,11 @@ + + + + + @@ -46,6 +51,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Analyzers/Core/CodeFixes/CodeFixesResources.resx b/src/Analyzers/Core/CodeFixes/CodeFixesResources.resx index 0583ac1ce8eaa..187f356cea199 100644 --- a/src/Analyzers/Core/CodeFixes/CodeFixesResources.resx +++ b/src/Analyzers/Core/CodeFixes/CodeFixesResources.resx @@ -267,4 +267,55 @@ TODO: override finalizer only if '{0}' has code to free unmanaged resources + + Generate constant '{0}' + + + Generate read-only field '{0}' + + + Generate read-only property '{0}' + + + Generate field '{0}' + + + Generate local '{0}' + + + Generate parameter '{0}' + + + Generate parameter '{0}' (and overrides/implementations) + + + Generate variable '{0}' + + + Generate enum member '{0}' + + + Generate abstract method '{0}' + + + Generate abstract property '{0}' + + + Generate method '{0}' + + + Generate property '{0}' + + + Generate narrowing conversion in '{0}' + + + Generate widening conversion in '{0}' + + + Generate implicit conversion operator in '{0}' + + + Generate explicit conversion operator in '{0}' + \ No newline at end of file diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.State.cs similarity index 95% rename from src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.State.cs index e5d5c77cc4a82..b592f43102233 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.State.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.State.cs @@ -13,6 +13,7 @@ using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.FindSymbols; +using Microsoft.CodeAnalysis.Host; using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.Extensions; @@ -20,6 +21,12 @@ using Microsoft.CodeAnalysis.Utilities; using Roslyn.Utilities; +#if CODE_STYLE +using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers; +#else +using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers; +#endif + namespace Microsoft.CodeAnalysis.GenerateMember.GenerateConstructor; internal abstract partial class AbstractGenerateConstructorService @@ -230,11 +237,20 @@ private bool TryInitializeDelegatedConstructor(CancellationToken cancellationTok return null; } + private TLanguageService GetRequiredLanguageService(string language) where TLanguageService : ILanguageService + { +#if CODE_STYLE + return _document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(language).GetRequiredService(); +#else + return _document.Project.Solution.Services.GetRequiredLanguageService(language); +#endif + } + private bool ClashesWithExistingConstructor() { Contract.ThrowIfNull(TypeToGenerateIn); - var syntaxFacts = _document.Project.Solution.Services.GetRequiredLanguageService(TypeToGenerateIn.Language); + var syntaxFacts = GetRequiredLanguageService(TypeToGenerateIn.Language); return TypeToGenerateIn.InstanceConstructors.Any(static (c, arg) => arg.self.Matches(c, arg.syntaxFacts), (self: this, syntaxFacts)); } @@ -574,10 +590,9 @@ public async Task GetChangedDocumentAsync( Contract.ThrowIfNull(TypeToGenerateIn); - var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); var (members, assignments) = await GenerateMembersAndAssignmentsAsync(document, withFields, withProperties, cancellationToken).ConfigureAwait(false); var isThis = _delegatedConstructor.ContainingType.OriginalDefinition.Equals(TypeToGenerateIn.OriginalDefinition); - var delegatingArguments = provider.GetRequiredService().CreateArguments(_delegatedConstructor.Parameters); + var delegatingArguments = this.GetRequiredLanguageService(TypeToGenerateIn.Language).CreateArguments(_delegatedConstructor.Parameters); var newParameters = _delegatedConstructor.Parameters.Concat(_parameters); var generateUnsafe = !IsContainedInUnsafeType && newParameters.Any(static p => p.RequiresUnsafeModifier()); @@ -596,7 +611,7 @@ public async Task GetChangedDocumentAsync( document.Project.Solution, new CodeGenerationContext(Token.GetLocation())); - return await provider.GetRequiredService().AddMembersAsync( + return await CodeGenerator.AddMemberDeclarationsAsync( context, TypeToGenerateIn, members.Concat(constructor), @@ -608,8 +623,6 @@ public async Task GetChangedDocumentAsync( { Contract.ThrowIfNull(TypeToGenerateIn); - var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); - var members = withFields ? SyntaxGeneratorExtensions.CreateFieldsForParameters(_parameters, ParameterToNewFieldMap, IsContainedInUnsafeType) : withProperties ? SyntaxGeneratorExtensions.CreatePropertiesForParameters(_parameters, ParameterToNewPropertyMap, IsContainedInUnsafeType) : []; @@ -617,7 +630,8 @@ public async Task GetChangedDocumentAsync( var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false); var assignments = !withFields && !withProperties ? [] - : provider.GetRequiredService().CreateAssignmentStatements( + : GetRequiredLanguageService(TypeToGenerateIn.Language).CreateAssignmentStatements( + GetRequiredLanguageService(TypeToGenerateIn.Language), semanticModel, _parameters, _parameterToExistingMemberMap, withFields ? ParameterToNewFieldMap : ParameterToNewPropertyMap, @@ -631,7 +645,6 @@ private async Task GenerateMemberDelegatingConstructorAsync( { Contract.ThrowIfNull(TypeToGenerateIn); - var provider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false); var newMemberMap = @@ -639,12 +652,13 @@ private async Task GenerateMemberDelegatingConstructorAsync( withProperties ? ParameterToNewPropertyMap : ImmutableDictionary.Empty; - return await provider.GetRequiredService().AddMembersAsync( + return await CodeGenerator.AddMemberDeclarationsAsync( new CodeGenerationSolutionContext( document.Project.Solution, new CodeGenerationContext(Token.GetLocation())), TypeToGenerateIn, - provider.GetRequiredService().CreateMemberDelegatingConstructor( + GetRequiredLanguageService(TypeToGenerateIn.Language).CreateMemberDelegatingConstructor( + GetRequiredLanguageService(TypeToGenerateIn.Language), semanticModel, TypeToGenerateIn.Name, TypeToGenerateIn, diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs b/src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs rename to src/Analyzers/Core/CodeFixes/GenerateConstructor/AbstractGenerateConstructorService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/Argument.cs b/src/Analyzers/Core/CodeFixes/GenerateConstructor/Argument.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateConstructor/Argument.cs rename to src/Analyzers/Core/CodeFixes/GenerateConstructor/Argument.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/GenerateConstructorHelpers.cs b/src/Analyzers/Core/CodeFixes/GenerateConstructor/GenerateConstructorHelpers.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateConstructor/GenerateConstructorHelpers.cs rename to src/Analyzers/Core/CodeFixes/GenerateConstructor/GenerateConstructorHelpers.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/IGenerateConstructorService.cs b/src/Analyzers/Core/CodeFixes/GenerateConstructor/IGenerateConstructorService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateConstructor/IGenerateConstructorService.cs rename to src/Analyzers/Core/CodeFixes/GenerateConstructor/IGenerateConstructorService.cs diff --git a/src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs index c3e6f5ce43eae..89d5653afbca1 100644 --- a/src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateDefaultConstructors/AbstractGenerateDefaultConstructorsService.AbstractCodeAction.cs @@ -46,8 +46,7 @@ protected AbstractCodeAction( protected override async Task GetChangedDocumentAsync(CancellationToken cancellationToken) { Contract.ThrowIfNull(_state.ClassType); - var generator = _document.GetRequiredLanguageService(); - var result = await generator.AddMembersAsync( + var result = await CodeGenerator.AddMemberDeclarationsAsync( new CodeGenerationSolutionContext( _document.Project.Solution, CodeGenerationContext.Default), diff --git a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs similarity index 88% rename from src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs rename to src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs index 48cf055fa3c7f..a406679dcb829 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.CodeAction.cs @@ -10,6 +10,7 @@ using Microsoft.CodeAnalysis.CodeGeneration; using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.Shared.Utilities; +using Microsoft.CodeAnalysis.Host; namespace Microsoft.CodeAnalysis.GenerateMember.GenerateEnumMember; @@ -22,7 +23,11 @@ private partial class GenerateEnumMemberCodeAction(Document document, State stat protected override async Task GetChangedDocumentAsync(CancellationToken cancellationToken) { +#if CODE_STYLE + var languageServices = _document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(_state.TypeToGenerateIn.Language); +#else var languageServices = _document.Project.Solution.Services.GetLanguageServices(_state.TypeToGenerateIn.Language); +#endif var codeGenerator = languageServices.GetService(); var semanticFacts = languageServices.GetService(); @@ -54,7 +59,7 @@ public override string Title get { return string.Format( - FeaturesResources.Generate_enum_member_0, _state.IdentifierToken.ValueText); + CodeFixesResources.Generate_enum_member_0, _state.IdentifierToken.ValueText); } } } diff --git a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.State.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.State.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateEnumMember/AbstractGenerateEnumMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateEnumMember/AbstractGenerateEnumMemberService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateEnumMember/IGenerateEnumMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateEnumMember/IGenerateEnumMemberService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateEnumMember/IGenerateEnumMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateEnumMember/IGenerateEnumMemberService.cs diff --git a/src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs similarity index 100% rename from src/Features/Core/Portable/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs rename to src/Analyzers/Core/CodeFixes/GenerateMember/AbstractGenerateMemberCodeFixProvider.cs diff --git a/src/Features/Core/Portable/GenerateMember/AbstractGenerateMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateMember/AbstractGenerateMemberService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/AbstractGenerateMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateMember/AbstractGenerateMemberService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateConversionService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateConversionService.State.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateConversionService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateConversionService.State.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateConversionService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateConversionService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateConversionService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateConversionService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs similarity index 97% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs index adefeff36e7b1..980e1980c24eb 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.State.cs @@ -47,7 +47,8 @@ private async Task TryInitializeMethodAsync( { TypeToGenerateIn = typeToGenerateIn; IsStatic = false; - var generator = SyntaxGenerator.GetGenerator(document.Document); + var generator = document.Document.GetRequiredLanguageService(); + IdentifierToken = generator.Identifier(WellKnownMemberNames.DeconstructMethodName); MethodGenerationKind = MethodGenerationKind.Member; MethodKind = MethodKind.Ordinary; diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateDeconstructMethodService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateMethodService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateMethodService.State.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateMethodService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateMethodService.State.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateMethodService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateMethodService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateMethodService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateMethodService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.AbstractInvocationInfo.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs similarity index 94% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs index 24dc35aa27167..2ab87259b4019 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.CodeAction.cs @@ -48,8 +48,8 @@ private string GetDisplayText( { case MethodGenerationKind.Member: var text = generateProperty - ? isAbstract ? FeaturesResources.Generate_abstract_property_0 : FeaturesResources.Generate_property_0 - : isAbstract ? FeaturesResources.Generate_abstract_method_0 : FeaturesResources.Generate_method_0; + ? isAbstract ? CodeFixesResources.Generate_abstract_property_0 : CodeFixesResources.Generate_property_0 + : isAbstract ? CodeFixesResources.Generate_abstract_method_0 : CodeFixesResources.Generate_method_0; var name = state.IdentifierToken.ValueText; return string.Format(text, name); diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs similarity index 97% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs index dcde4780a25f6..a985fefa216b0 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.SignatureInfo.cs @@ -13,12 +13,19 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CodeGeneration; using Microsoft.CodeAnalysis.Editing; +using Microsoft.CodeAnalysis.Host; using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.Shared.Extensions; using Microsoft.CodeAnalysis.Shared.Utilities; using Microsoft.CodeAnalysis.Utilities; using Roslyn.Utilities; +#if CODE_STYLE +using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers; +#else +using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers; +#endif + namespace Microsoft.CodeAnalysis.GenerateMember.GenerateParameterizedMember; internal abstract partial class AbstractGenerateParameterizedMemberService @@ -118,7 +125,12 @@ public async ValueTask GenerateMethodAsync( methodKind: State.MethodKind); // Ensure no conflicts between type parameter names and parameter names. +#if CODE_STYLE + var languageServiceProvider = Document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(State.TypeToGenerateIn.Language); +#else var languageServiceProvider = Document.Project.Solution.Services.GetLanguageServices(State.TypeToGenerateIn.Language); +#endif + var syntaxFacts = languageServiceProvider.GetService(); var equalityComparer = syntaxFacts.StringComparer; diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs similarity index 92% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs index 59fa09abb2e3b..9e0238d40b596 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.State.cs @@ -13,6 +13,7 @@ using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.Shared.Extensions; using Microsoft.CodeAnalysis.Shared.Utilities; +using Microsoft.CodeAnalysis.Host; namespace Microsoft.CodeAnalysis.GenerateMember.GenerateParameterizedMember; @@ -77,10 +78,16 @@ protected async Task TryFinishInitializingStateAsync(TService service, Sem // errors. In the former case we definitely want to offer to generate a method. In // the latter case, we want to generate a method *unless* there's an existing method // with the same signature. - var existingMethods = TypeToGenerateIn.GetMembers(IdentifierToken.ValueText) - .OfType(); + var existingMethods = TypeToGenerateIn + .GetMembers(IdentifierToken.ValueText) + .OfType(); +#if CODE_STYLE + var destinationProvider = document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(TypeToGenerateIn.Language); +#else var destinationProvider = document.Project.Solution.Services.GetLanguageServices(TypeToGenerateIn.Language); +#endif + var syntaxFacts = destinationProvider.GetService(); var syntaxFactory = destinationProvider.GetService(); IsContainedInUnsafeType = service.ContainingTypesOrSelfHasUnsafeKeyword(TypeToGenerateIn); diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs similarity index 94% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs index fef378293e666..bc8ba4ff7c24e 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/AbstractGenerateParameterizedMemberService.cs @@ -8,7 +8,7 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis.CodeActions; -using Microsoft.CodeAnalysis.CodeGeneration; +using Microsoft.CodeAnalysis.Host; using Microsoft.CodeAnalysis.LanguageService; using Microsoft.CodeAnalysis.PooledObjects; @@ -54,7 +54,11 @@ protected async ValueTask> GetActionsAsync(Document d if (canGenerateAbstractly) result.Add(new GenerateParameterizedMemberCodeAction((TService)this, document, state, isAbstract: true, generateProperty: false)); +#if CODE_STYLE + var semanticFacts = document.Project.Solution.Workspace.Services.GetExtendedLanguageServices(state.TypeToGenerateIn.Language).GetService(); +#else var semanticFacts = document.Project.Solution.Services.GetLanguageServices(state.TypeToGenerateIn.Language).GetService(); +#endif if (semanticFacts.SupportsParameterizedProperties && state.InvocationExpressionOpt != null) diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateConversionService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateConversionService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateConversionService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateConversionService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateDeconstructMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateDeconstructMemberService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateDeconstructMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateDeconstructMemberService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateParameterizedMemberService.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateParameterizedMemberService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/IGenerateParameterizedMemberService.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/IGenerateParameterizedMemberService.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/MethodGenerationKind.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/MethodGenerationKind.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/MethodGenerationKind.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/MethodGenerationKind.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/TypeParameterSubstitution.cs b/src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/TypeParameterSubstitution.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateParameterizedMember/TypeParameterSubstitution.cs rename to src/Analyzers/Core/CodeFixes/GenerateParameterizedMember/TypeParameterSubstitution.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs similarity index 94% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs index 4c5a8e168bf49..40c1f1795eef3 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.CodeAction.cs @@ -15,6 +15,12 @@ using Microsoft.CodeAnalysis.Shared.Extensions; using Roslyn.Utilities; +#if CODE_STYLE +using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers; +#else +using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers; +#endif + namespace Microsoft.CodeAnalysis.GenerateMember.GenerateVariable; internal abstract partial class AbstractGenerateVariableService @@ -177,10 +183,10 @@ public override string Title get { var text = _isConstant - ? FeaturesResources.Generate_constant_0 + ? CodeFixesResources.Generate_constant_0 : _generateProperty - ? _isReadonly ? FeaturesResources.Generate_read_only_property_0 : FeaturesResources.Generate_property_0 - : _isReadonly ? FeaturesResources.Generate_read_only_field_0 : FeaturesResources.Generate_field_0; + ? _isReadonly ? CodeFixesResources.Generate_read_only_property_0 : CodeFixesResources.Generate_property_0 + : _isReadonly ? CodeFixesResources.Generate_read_only_field_0 : CodeFixesResources.Generate_field_0; return string.Format( text, diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs similarity index 97% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs index 27009e75e9acf..1cd52ccd264cc 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateLocalCodeAction.cs @@ -28,7 +28,7 @@ public override string Title { get { - var text = FeaturesResources.Generate_local_0; + var text = CodeFixesResources.Generate_local_0; return string.Format( text, diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs similarity index 92% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs index ab8cff038de7f..22463a0abd335 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.GenerateParameterCodeAction.cs @@ -25,8 +25,8 @@ public override string Title get { var text = _includeOverridesAndImplementations - ? FeaturesResources.Generate_parameter_0_and_overrides_implementations - : FeaturesResources.Generate_parameter_0; + ? CodeFixesResources.Generate_parameter_0_and_overrides_implementations + : CodeFixesResources.Generate_parameter_0; return string.Format( text, diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.State.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.State.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.State.cs diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.cs similarity index 99% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.cs index 3aa8496a69924..a6e6702cd5762 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs +++ b/src/Analyzers/Core/CodeFixes/GenerateVariable/AbstractGenerateVariableService.cs @@ -80,7 +80,7 @@ public async Task> GenerateVariableAsync( // Wrap the generate variable actions into a single top level suggestion // so as to not clutter the list. return [CodeAction.Create( - string.Format(FeaturesResources.Generate_variable_0, state.IdentifierToken.ValueText), + string.Format(CodeFixesResources.Generate_variable_0, state.IdentifierToken.ValueText), actions.ToImmutable(), isInlinable: true)]; } diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/IGenerateVariableService.cs b/src/Analyzers/Core/CodeFixes/GenerateVariable/IGenerateVariableService.cs similarity index 100% rename from src/Features/Core/Portable/GenerateMember/GenerateVariable/IGenerateVariableService.cs rename to src/Analyzers/Core/CodeFixes/GenerateVariable/IGenerateVariableService.cs diff --git a/src/Analyzers/Core/CodeFixes/ImplementAbstractClass/ImplementAbstractClassData.cs b/src/Analyzers/Core/CodeFixes/ImplementAbstractClass/ImplementAbstractClassData.cs index f10fd4b026a4e..b1e7588ff6615 100644 --- a/src/Analyzers/Core/CodeFixes/ImplementAbstractClass/ImplementAbstractClassData.cs +++ b/src/Analyzers/Core/CodeFixes/ImplementAbstractClass/ImplementAbstractClassData.cs @@ -57,8 +57,7 @@ internal sealed class ImplementAbstractClassData( if (abstractClassType == null || !abstractClassType.IsAbstractClass()) return null; - var generator = document.GetRequiredLanguageService(); - if (!generator.CanAddTo(classType, document.Project.Solution, cancellationToken)) + if (!CodeGenerator.CanAdd(document.Project.Solution, classType, cancellationToken)) return null; var unimplementedMembers = classType.GetAllUnimplementedMembers( diff --git a/src/Analyzers/Core/CodeFixes/ImplementInterface/AbstractImplementInterfaceService.State.cs b/src/Analyzers/Core/CodeFixes/ImplementInterface/AbstractImplementInterfaceService.State.cs index d718a23ebd75d..feb8d03fedd17 100644 --- a/src/Analyzers/Core/CodeFixes/ImplementInterface/AbstractImplementInterfaceService.State.cs +++ b/src/Analyzers/Core/CodeFixes/ImplementInterface/AbstractImplementInterfaceService.State.cs @@ -47,8 +47,7 @@ internal sealed class State( return null; } - var generator = document.GetRequiredLanguageService(); - if (!generator.CanAddTo(classOrStructType, document.Project.Solution, cancellationToken)) + if (!CodeGenerator.CanAdd(document.Project.Solution, classOrStructType, cancellationToken)) { return null; } diff --git a/src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs b/src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs index 6176d02f16af8..c950b2e54a02a 100644 --- a/src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs +++ b/src/Analyzers/Core/CodeFixes/ImplementInterface/ImplementInterfaceGenerator.cs @@ -91,8 +91,7 @@ private async Task ImplementInterfaceAsync( var groupMembers = !isComImport && Options.InsertionBehavior == ImplementTypeInsertionBehavior.WithOtherMembersOfTheSameKind; - var generator = this.Document.GetRequiredLanguageService(); - return await generator.AddMembersAsync( + return await CodeGenerator.AddMemberDeclarationsAsync( new CodeGenerationSolutionContext( this.Document.Project.Solution, new CodeGenerationContext( diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.cs.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.cs.xlf index 244bb7c3abf45..45e3c49828341 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.cs.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.cs.xlf @@ -77,11 +77,26 @@ Opravit porušení názvu: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.de.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.de.xlf index 9c4bdbc60cf79..9f83900115ece 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.de.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.de.xlf @@ -77,11 +77,26 @@ Namensverletzung beheben: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.es.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.es.xlf index 91536cdff9df8..193368b66ad71 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.es.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.es.xlf @@ -77,11 +77,26 @@ Corregir infracción de nombre: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.fr.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.fr.xlf index 0eaa688716400..e3f51e039601d 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.fr.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.fr.xlf @@ -77,11 +77,26 @@ Corrigez la violation de nom : {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.it.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.it.xlf index 62b2de323d303..31090b372b9c0 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.it.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.it.xlf @@ -77,11 +77,26 @@ Correggi violazione del nome: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ja.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ja.xlf index bd09e0417ed4e..68bf2e60a939d 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ja.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ja.xlf @@ -77,11 +77,26 @@ 名前の違反を修正します: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ko.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ko.xlf index ce339eb4bb48b..9512b178f9f51 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ko.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ko.xlf @@ -77,11 +77,26 @@ 이름 위반 수정: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pl.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pl.xlf index 8cabbbcd04e1c..2dfb6a43e4c5f 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pl.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pl.xlf @@ -77,11 +77,26 @@ Rozwiąż problem z naruszeniem nazwy: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pt-BR.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pt-BR.xlf index 1ba6afe712798..493978f373bf6 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pt-BR.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.pt-BR.xlf @@ -77,11 +77,26 @@ Corrigir violação de nome: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ru.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ru.xlf index e79843df0f768..10a02bfa8ca26 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ru.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.ru.xlf @@ -77,11 +77,26 @@ Устраните нарушение имени: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.tr.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.tr.xlf index b5384be02a46e..a2c15d1babdf4 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.tr.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.tr.xlf @@ -77,11 +77,26 @@ Ad ihlalini düzelt: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hans.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hans.xlf index 263a2f9788fde..d616b72a519a3 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hans.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hans.xlf @@ -77,11 +77,26 @@ 解决名称冲突: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hant.xlf b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hant.xlf index 3f452fc1faae9..00b98d172bfc4 100644 --- a/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hant.xlf +++ b/src/Analyzers/Core/CodeFixes/xlf/CodeFixesResources.zh-Hant.xlf @@ -77,11 +77,26 @@ 修正名稱違規: {0} + + Generate abstract method '{0}' + Generate abstract method '{0}' + + + + Generate abstract property '{0}' + Generate abstract property '{0}' + + Generate all Generate all + + Generate constant '{0}' + Generate constant '{0}' + + Generate constructor '{0}({1})' Generate constructor '{0}({1})' @@ -102,11 +117,81 @@ Generate constructor in '{0}' (with properties) + + Generate enum member '{0}' + Generate enum member '{0}' + + + + Generate explicit conversion operator in '{0}' + Generate explicit conversion operator in '{0}' + + + + Generate field '{0}' + Generate field '{0}' + + Generate field assigning constructor '{0}({1})' Generate field assigning constructor '{0}({1})' + + Generate implicit conversion operator in '{0}' + Generate implicit conversion operator in '{0}' + + + + Generate local '{0}' + Generate local '{0}' + + + + Generate method '{0}' + Generate method '{0}' + + + + Generate narrowing conversion in '{0}' + Generate narrowing conversion in '{0}' + + + + Generate parameter '{0}' + Generate parameter '{0}' + + + + Generate parameter '{0}' (and overrides/implementations) + Generate parameter '{0}' (and overrides/implementations) + + + + Generate property '{0}' + Generate property '{0}' + + + + Generate read-only field '{0}' + Generate read-only field '{0}' + + + + Generate read-only property '{0}' + Generate read-only property '{0}' + + + + Generate variable '{0}' + Generate variable '{0}' + + + + Generate widening conversion in '{0}' + Generate widening conversion in '{0}' + + Implement all members explicitly Implement all members explicitly diff --git a/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.vb similarity index 97% rename from src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.vb index 850b3ec580a61..3992689a627f3 100644 --- a/src/Features/VisualBasic/Portable/GenerateConstructor/GenerateConstructorCodeFixProvider.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateConstructor/GenerateConstructorCodeFixProvider.vb @@ -15,10 +15,9 @@ Imports Microsoft.CodeAnalysis.GenerateMember.GenerateConstructor Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor - - Friend Class GenerateConstructorCodeFixProvider + Friend NotInheritable Class GenerateConstructorCodeFixProvider Inherits AbstractGenerateMemberCodeFixProvider diff --git a/src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateConstructor/VisualBasicGenerateConstructorService.vb similarity index 100% rename from src/Features/VisualBasic/Portable/GenerateConstructor/VisualBasicGenerateConstructorService.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateConstructor/VisualBasicGenerateConstructorService.vb diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb similarity index 97% rename from src/Features/VisualBasic/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb index 408486abd861d..276998efdd7b1 100644 --- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/GenerateEnumMemberCodeFixProvider.vb @@ -16,7 +16,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEnumMember - Friend Class GenerateEnumMemberCodeFixProvider + Friend NotInheritable Class GenerateEnumMemberCodeFixProvider Inherits AbstractGenerateMemberCodeFixProvider Friend Const BC30456 As String = "BC30456" ' error BC30456: 'Red' is not a member of 'Color'. diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb similarity index 97% rename from src/Features/VisualBasic/Portable/GenerateMember/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb index 524e172962db2..4fcbabb52aef4 100644 --- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateEnumMember/VisualBasicGenerateEnumMemberService.vb @@ -11,7 +11,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateEnumMember - Partial Friend Class VisualBasicGenerateEnumMemberService + Partial Friend NotInheritable Class VisualBasicGenerateEnumMemberService Inherits AbstractGenerateEnumMemberService(Of VisualBasicGenerateEnumMemberService, SimpleNameSyntax, ExpressionSyntax) diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb similarity index 97% rename from src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb index 66f6f65869b15..eba274d4bf834 100644 --- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateConversionCodeFixProvider.vb @@ -16,7 +16,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateMethod - Friend Class GenerateConversionCodeFixProvider + Friend NotInheritable Class GenerateConversionCodeFixProvider Inherits AbstractGenerateMemberCodeFixProvider Friend Const BC30311 As String = "BC30311" ' error BC30311: Cannot convert type 'x' to type 'y' diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb similarity index 98% rename from src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb index a4306b7efc38b..ab2feaf6fe4e9 100644 --- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/GenerateParameterizedMemberCodeFixProvider.vb @@ -16,7 +16,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateMethod - Friend Class GenerateParameterizedMemberCodeFixProvider + Friend NotInheritable Class GenerateParameterizedMemberCodeFixProvider Inherits AbstractGenerateMemberCodeFixProvider Friend Const BC30057 As String = "BC30057" ' error BC30057: Too many arguments to 'Public Sub Baz()' diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicCommonGenerationServiceMethods.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicCommonGenerationServiceMethods.vb similarity index 100% rename from src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicCommonGenerationServiceMethods.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicCommonGenerationServiceMethods.vb diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb similarity index 97% rename from src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb index c11b85604a33b..4a8becca9d097 100644 --- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateConversionService.vb @@ -13,7 +13,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod - Partial Friend Class VisualBasicGenerateConversionService + Partial Friend NotInheritable Class VisualBasicGenerateConversionService Inherits AbstractGenerateConversionService(Of VisualBasicGenerateConversionService, SimpleNameSyntax, ExpressionSyntax, InvocationExpressionSyntax) @@ -164,11 +164,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod End Function Protected Overrides Function GetExplicitConversionDisplayText(state As AbstractGenerateParameterizedMemberService(Of VisualBasicGenerateConversionService, SimpleNameSyntax, ExpressionSyntax, InvocationExpressionSyntax).State) As String - Return String.Format(VBFeaturesResources.Generate_narrowing_conversion_in_0, state.TypeToGenerateIn.Name) + Return String.Format(CodeFixesResources.Generate_narrowing_conversion_in_0, state.TypeToGenerateIn.Name) End Function Protected Overrides Function GetImplicitConversionDisplayText(state As AbstractGenerateParameterizedMemberService(Of VisualBasicGenerateConversionService, SimpleNameSyntax, ExpressionSyntax, InvocationExpressionSyntax).State) As String - Return String.Format(VBFeaturesResources.Generate_widening_conversion_in_0, state.TypeToGenerateIn.Name) + Return String.Format(CodeFixesResources.Generate_widening_conversion_in_0, state.TypeToGenerateIn.Name) End Function End Class End Namespace diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb similarity index 98% rename from src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb index 27de6db3d16ad..11ad944d7ebd9 100644 --- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateMethodService.vb @@ -13,7 +13,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod - Partial Friend Class VisualBasicGenerateMethodService + Partial Friend NotInheritable Class VisualBasicGenerateMethodService Inherits AbstractGenerateMethodService(Of VisualBasicGenerateMethodService, SimpleNameSyntax, ExpressionSyntax, InvocationExpressionSyntax) @@ -116,7 +116,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod invocationExpressionOpt = DirectCast(simpleNameOrMemberAccessExpression.Parent, InvocationExpressionSyntax) Return invocationExpressionOpt.ArgumentList Is Nothing OrElse Not invocationExpressionOpt.ArgumentList.CloseParenToken.IsMissing - ElseIf TryCast(TryCast(TryCast(simpleNameOrMemberAccessExpression, ConditionalAccessExpressionSyntax)?.WhenNotNull, InvocationExpressionSyntax)?.Expression, MemberAccessExpressionSyntax)?.Name Is simpleName + ElseIf TryCast(TryCast(TryCast(simpleNameOrMemberAccessExpression, ConditionalAccessExpressionSyntax)?.WhenNotNull, InvocationExpressionSyntax)?.Expression, MemberAccessExpressionSyntax)?.Name Is simpleName Then invocationExpressionOpt = DirectCast(DirectCast(simpleNameOrMemberAccessExpression, ConditionalAccessExpressionSyntax).WhenNotNull, InvocationExpressionSyntax) Return invocationExpressionOpt.ArgumentList Is Nothing OrElse Not invocationExpressionOpt.ArgumentList.CloseParenToken.IsMissing diff --git a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb similarity index 99% rename from src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb index 7823eb6fdc4e0..677d27c679149 100644 --- a/src/Features/VisualBasic/Portable/GenerateMember/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateParameterizedMember/VisualBasicGenerateParameterizedMemberService.vb @@ -54,7 +54,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateMember.GenerateMethod Return Me.Document.SemanticModel.Compilation.GetSpecialType(SpecialType.System_String) End Select - Dim typeInference = Document.Project.Services.GetService(Of ITypeInferenceService)() + Dim typeInference = Document.Document.GetRequiredLanguageService(Of ITypeInferenceService)() Dim inferredType = typeInference.InferType( Document.SemanticModel, Me.InvocationExpression, objectAsDefault:=True, name:=Me.State.IdentifierToken.ValueText, cancellationToken:=cancellationToken) diff --git a/src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb b/src/Analyzers/VisualBasic/CodeFixes/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb similarity index 97% rename from src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb rename to src/Analyzers/VisualBasic/CodeFixes/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb index b5b81092baacc..d2e40b57a8b73 100644 --- a/src/Features/VisualBasic/Portable/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb +++ b/src/Analyzers/VisualBasic/CodeFixes/GenerateVariable/VisualBasicGenerateVariableCodeFixProvider.vb @@ -16,7 +16,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.Syntax Namespace Microsoft.CodeAnalysis.VisualBasic.GenerateVariable - Friend Class VisualBasicGenerateVariableCodeFixProvider + Friend NotInheritable Class VisualBasicGenerateVariableCodeFixProvider Inherits AbstractGenerateMemberCodeFixProvider Friend Const BC30456 As String = "BC30456" ' error BC30456: 'Goo' is not a member of 'P'. diff --git a/src/Analyzers/VisualBasic/CodeFixes/VisualBasicCodeFixes.projitems b/src/Analyzers/VisualBasic/CodeFixes/VisualBasicCodeFixes.projitems index d5673680f3e38..ee4eb2bcc0332 100644 --- a/src/Analyzers/VisualBasic/CodeFixes/VisualBasicCodeFixes.projitems +++ b/src/Analyzers/VisualBasic/CodeFixes/VisualBasicCodeFixes.projitems @@ -27,9 +27,20 @@ + + + + + + + + + + + diff --git a/src/Features/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb b/src/Analyzers/VisualBasic/Tests/GenerateConstructor/GenerateConstructorTests.vb similarity index 99% rename from src/Features/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb rename to src/Analyzers/VisualBasic/Tests/GenerateConstructor/GenerateConstructorTests.vb index a621c3601e426..4d8e0645acec8 100644 --- a/src/Features/VisualBasicTest/GenerateConstructor/GenerateConstructorTests.vb +++ b/src/Analyzers/VisualBasic/Tests/GenerateConstructor/GenerateConstructorTests.vb @@ -10,7 +10,7 @@ Imports Microsoft.CodeAnalysis.VisualBasic.GenerateConstructor Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.GenerateConstructor - Public Class GenerateConstructorTests + Public NotInheritable Class GenerateConstructorTests Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_NoEditor Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As (DiagnosticAnalyzer, CodeFixProvider) @@ -1386,55 +1386,6 @@ Public Class D End Class") End Function - - Public Async Function TestAttributesWithAllValidArguments() As Task - Await TestInRegularAndScriptAsync( -"Enum A - A1 -End Enum - -Public Class MyAttribute - Inherits System.Attribute -End Class -[||] -Public Class D End Class", -"Enum A - A1 -End Enum - -Public Class MyAttribute - Inherits System.Attribute - - Private shorts As Short() - Private a1 As A - Private v1 As Boolean - Private v2 As Integer - Private v3 As Char - Private v4 As Short - Private v5 As Integer - Private v6 As Long - Private v7 As Double - Private v8 As Single - Private v9 As String - - Public Sub New(shorts() As Short, a1 As A, v1 As Boolean, v2 As Integer, v3 As Char, v4 As Short, v5 As Integer, v6 As Long, v7 As Double, v8 As Single, v9 As String) - Me.shorts = shorts - Me.a1 = a1 - Me.v1 = v1 - Me.v2 = v2 - Me.v3 = v3 - Me.v4 = v4 - Me.v5 = v5 - Me.v6 = v6 - Me.v7 = v7 - Me.v8 = v8 - Me.v9 = v9 - End Sub -End Class - -Public Class D End Class") - End Function - Public Async Function TestAttributesWithLambda() As Task Await TestMissingInRegularAndScriptAsync( @@ -1909,94 +1860,6 @@ Public Class B End Class") End Function - - Public Async Function TestDelegateConstructorCrossLanguage() As Task - Await TestInRegularAndScriptAsync( - - - -public class BaseType -{ - public BaseType(string x) { } -} - - - CSharpProject - -Option Strict On - -Public Class B - Public Sub M() - Dim x = [|New BaseType(42)|] - End Sub -End Class - - -.ToString(), -" -public class BaseType -{ - private int v; - - public BaseType(string x) { } - - public BaseType(int v) - { - this.v = v; - } -}") - End Function - - - Public Async Function TestDelegateConstructorCrossLanguageWithMissingType() As Task - Await TestAsync( - - - -public class ExtraType { } - - - - CSharpProjectWithExtraType - -public class C -{ - public C(ExtraType t) { } - public C(string s, int i) { } -} - - - - CSharpProjectGeneratingInto - -Option Strict On - -Public Class B - Public Sub M() - Dim x = [|New C(42, 42)|] - End Sub -End Class - - -.ToString(), -" -public class C -{ - private int v1; - private int v2; - - public C(ExtraType t) { } - public C(string s, int i) { } - - public C(int v1, int v2) - { - this.v1 = v1; - this.v2 = v2; - } -} - ", TestOptions.Regular) - End Function - Public Async Function CreateFieldDefaultNamingStyle() As Task Await TestInRegularAndScriptAsync( @@ -2114,39 +1977,6 @@ End Class ") End Function - - Public Async Function TestGenerateNameFromTypeArgument() As Task - Await TestInRegularAndScriptAsync( -"Imports System.Collections.Generic - -Class Frog -End Class - -Class C - Private Function M() As C - Return New C([||]New List(Of Frog)()) - End Function -End Class -", -"Imports System.Collections.Generic - -Class Frog -End Class - -Class C - Private frogs As List(Of Frog) - - Public Sub New(frogs As List(Of Frog)) - Me.frogs = frogs - End Sub - - Private Function M() As C - Return New C(New List(Of Frog)()) - End Function -End Class -") - End Function - Public Async Function TestDoNotGenerateNameFromTypeArgumentIfNotEnumerable() As Task Await TestInRegularAndScriptAsync( @@ -2284,5 +2114,179 @@ End Class ") End Function +#If Not CODE_STYLE Then + + + Public Async Function TestAttributesWithAllValidArguments() As Task + Await TestInRegularAndScriptAsync( +"Enum A + A1 +End Enum + +Public Class MyAttribute + Inherits System.Attribute +End Class +[||] +Public Class D End Class", +"Enum A + A1 +End Enum + +Public Class MyAttribute + Inherits System.Attribute + + Private shorts As Short() + Private a1 As A + Private v1 As Boolean + Private v2 As Integer + Private v3 As Char + Private v4 As Short + Private v5 As Integer + Private v6 As Long + Private v7 As Double + Private v8 As Single + Private v9 As String + + Public Sub New(shorts() As Short, a1 As A, v1 As Boolean, v2 As Integer, v3 As Char, v4 As Short, v5 As Integer, v6 As Long, v7 As Double, v8 As Single, v9 As String) + Me.shorts = shorts + Me.a1 = a1 + Me.v1 = v1 + Me.v2 = v2 + Me.v3 = v3 + Me.v4 = v4 + Me.v5 = v5 + Me.v6 = v6 + Me.v7 = v7 + Me.v8 = v8 + Me.v9 = v9 + End Sub +End Class + +Public Class D End Class") + End Function + + + Public Async Function TestDelegateConstructorCrossLanguage() As Task + Await TestInRegularAndScriptAsync( + + + +public class BaseType +{ + public BaseType(string x) { } +} + + + CSharpProject + +Option Strict On + +Public Class B + Public Sub M() + Dim x = [|New BaseType(42)|] + End Sub +End Class + + +.ToString(), +" +public class BaseType +{ + private int v; + + public BaseType(string x) { } + + public BaseType(int v) + { + this.v = v; + } +}") + End Function + + + Public Async Function TestDelegateConstructorCrossLanguageWithMissingType() As Task + Await TestAsync( + + + +public class ExtraType { } + + + + CSharpProjectWithExtraType + +public class C +{ + public C(ExtraType t) { } + public C(string s, int i) { } +} + + + + CSharpProjectGeneratingInto + +Option Strict On + +Public Class B + Public Sub M() + Dim x = [|New C(42, 42)|] + End Sub +End Class + + +.ToString(), +" +public class C +{ + private int v1; + private int v2; + + public C(ExtraType t) { } + public C(string s, int i) { } + + public C(int v1, int v2) + { + this.v1 = v1; + this.v2 = v2; + } +} + ", TestOptions.Regular) + End Function + + + Public Async Function TestGenerateNameFromTypeArgument() As Task + Await TestInRegularAndScriptAsync( +"Imports System.Collections.Generic + +Class Frog +End Class + +Class C + Private Function M() As C + Return New C([||]New List(Of Frog)()) + End Function +End Class +", +"Imports System.Collections.Generic + +Class Frog +End Class + +Class C + Private frogs As List(Of Frog) + + Public Sub New(frogs As List(Of Frog)) + Me.frogs = frogs + End Sub + + Private Function M() As C + Return New C(New List(Of Frog)()) + End Function +End Class +") + End Function + +#End If + End Class End Namespace diff --git a/src/Features/VisualBasicTest/GenerateEnumMember/GenerateEnumMemberTests.vb b/src/Analyzers/VisualBasic/Tests/GenerateEnumMember/GenerateEnumMemberTests.vb similarity index 99% rename from src/Features/VisualBasicTest/GenerateEnumMember/GenerateEnumMemberTests.vb rename to src/Analyzers/VisualBasic/Tests/GenerateEnumMember/GenerateEnumMemberTests.vb index 2507f10f089d1..af76a833710ba 100644 --- a/src/Features/VisualBasicTest/GenerateEnumMember/GenerateEnumMemberTests.vb +++ b/src/Analyzers/VisualBasic/Tests/GenerateEnumMember/GenerateEnumMemberTests.vb @@ -8,7 +8,7 @@ Imports Microsoft.CodeAnalysis.Diagnostics Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.GenerateEnumMember - Public Class GenerateEnumMemberTests + Public NotInheritable Class GenerateEnumMemberTests Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_NoEditor Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As (DiagnosticAnalyzer, CodeFixProvider) diff --git a/src/Features/VisualBasicTest/GenerateMethod/GenerateConversionTests.vb b/src/Analyzers/VisualBasic/Tests/GenerateMethod/GenerateConversionTests.vb similarity index 99% rename from src/Features/VisualBasicTest/GenerateMethod/GenerateConversionTests.vb rename to src/Analyzers/VisualBasic/Tests/GenerateMethod/GenerateConversionTests.vb index 995ae22d0eb83..96318debc1e5f 100644 --- a/src/Features/VisualBasicTest/GenerateMethod/GenerateConversionTests.vb +++ b/src/Analyzers/VisualBasic/Tests/GenerateMethod/GenerateConversionTests.vb @@ -9,7 +9,7 @@ Imports Microsoft.CodeAnalysis.Diagnostics Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Diagnostics.GenerateMethod Partial Public Class GenerateMethodTests - Public Class GenerateConversionTests + Public NotInheritable Class GenerateConversionTests Inherits AbstractVisualBasicDiagnosticProviderBasedUserDiagnosticTest_NoEditor Friend Overrides Function CreateDiagnosticProviderAndFixer(workspace As Workspace) As (DiagnosticAnalyzer, CodeFixProvider) diff --git a/src/Analyzers/VisualBasic/Tests/VisualBasicAnalyzers.UnitTests.projitems b/src/Analyzers/VisualBasic/Tests/VisualBasicAnalyzers.UnitTests.projitems index 686b3b663fe2a..9f5434bfc464c 100644 --- a/src/Analyzers/VisualBasic/Tests/VisualBasicAnalyzers.UnitTests.projitems +++ b/src/Analyzers/VisualBasic/Tests/VisualBasicAnalyzers.UnitTests.projitems @@ -23,7 +23,10 @@ + + + diff --git a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx index 13d4e8e6195ea..e14e82032ac9c 100644 --- a/src/Features/CSharp/Portable/CSharpFeaturesResources.resx +++ b/src/Features/CSharp/Portable/CSharpFeaturesResources.resx @@ -211,12 +211,6 @@ Organize Usings - - Generate explicit conversion operator in '{0}' - - - Generate implicit conversion operator in '{0}' - try block {Locked="try"} "try" is a C# keyword and should not be localized. diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf index 7f0533d300048..7c277d113addf 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf @@ -422,16 +422,6 @@ Uspořádat direktivy using - - Generate explicit conversion operator in '{0}' - Generovat explicitní operátor převodu v {0} - - - - Generate implicit conversion operator in '{0}' - Generovat implicitní operátor převodu v {0} - - record záznam diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf index 1e7b07b7e8b6f..43abdee07e7c8 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf @@ -422,16 +422,6 @@ Using-Direktiven organisieren - - Generate explicit conversion operator in '{0}' - Expliziten Konversionsoperator in '{0}' generieren - - - - Generate implicit conversion operator in '{0}' - Impliziten Konversionsoperator in '{0}' generieren - - record Datensatz diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf index 83a293824024e..fb1506e889134 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf @@ -422,16 +422,6 @@ Organizar instrucciones Using - - Generate explicit conversion operator in '{0}' - Generar operador de conversión explícito en '{0}' - - - - Generate implicit conversion operator in '{0}' - Generar operador de conversión implícito en '{0}' - - record registro diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf index 6e703336084c1..c3660c23351bb 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf @@ -422,16 +422,6 @@ Organiser les instructions Using - - Generate explicit conversion operator in '{0}' - Générer l’opérateur de conversion explicite dans « {0} » - - - - Generate implicit conversion operator in '{0}' - Générer l’opérateur de conversion implicite dans « {0} » - - record enregistrement diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf index fff92a6b43f6f..d781f9904657c 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf @@ -422,16 +422,6 @@ Organizza using - - Generate explicit conversion operator in '{0}' - Genera l'operatore di conversione esplicito in '{0}' - - - - Generate implicit conversion operator in '{0}' - Genera l'operatore di conversione implicito in '{0}' - - record record diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf index b757ebe7f5e27..261bbf1413967 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf @@ -422,16 +422,6 @@ using の整理 - - Generate explicit conversion operator in '{0}' - 明示的な変換演算子を '{0}' に生成します - - - - Generate implicit conversion operator in '{0}' - 暗黙的な変換演算子を '{0}' に生成します - - record レコード diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf index 474c98f6aff17..5bc2e5b7bcf2e 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf @@ -422,16 +422,6 @@ Using 구성 - - Generate explicit conversion operator in '{0}' - '{0}'에서 명시적 변환 연산자 생성 - - - - Generate implicit conversion operator in '{0}' - '{0}'에서 암시적 변환 연산자 생성 - - record 레코드 diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf index 2e48e00f969d1..af1a6a9a74558 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pl.xlf @@ -422,16 +422,6 @@ Organizuj użycia - - Generate explicit conversion operator in '{0}' - Generuj operator jawnej konwersji w elemencie „{0}” - - - - Generate implicit conversion operator in '{0}' - Generuj operator niejawnej konwersji w elemencie „{0}” - - record rekord diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf index e9132a814721f..8a38cb15bb1ec 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.pt-BR.xlf @@ -422,16 +422,6 @@ Organizar Usos - - Generate explicit conversion operator in '{0}' - Gerar um operador de conversão explícita em '{0}' - - - - Generate implicit conversion operator in '{0}' - Gerar um operador de conversão implícita em '{0}' - - record registro diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf index 4aba44a091853..fba75ab606895 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ru.xlf @@ -422,16 +422,6 @@ Упорядочение Using - - Generate explicit conversion operator in '{0}' - Создать явный оператор преобразования в "{0}" - - - - Generate implicit conversion operator in '{0}' - Создать неявный оператор преобразования в "{0}" - - record запись diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf index 4d452af524791..ee5a5cf4b1dcb 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.tr.xlf @@ -422,16 +422,6 @@ Kullanımları Düzenle - - Generate explicit conversion operator in '{0}' - '{0}' içinde açık dönüşüm işleci oluştur - - - - Generate implicit conversion operator in '{0}' - '{0}' içinde örtük dönüşüm işleci oluştur - - record kayıt diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf index e2ef3d0802186..241b9c403b1b2 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hans.xlf @@ -422,16 +422,6 @@ 组织 Using - - Generate explicit conversion operator in '{0}' - 在“{0}”中生成显示转换运算符 - - - - Generate implicit conversion operator in '{0}' - 在“{0}”中生成隐式转换运算符 - - record 记录 diff --git a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf index 312afb20a8fb6..645b87cd0be55 100644 --- a/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf +++ b/src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.zh-Hant.xlf @@ -422,16 +422,6 @@ 組合管理 Using - - Generate explicit conversion operator in '{0}' - 在 '{0}' 中產生明確轉換運算子 - - - - Generate implicit conversion operator in '{0}' - 在 '{0}' 中產生隱含轉換運算子 - - record 記錄 diff --git a/src/Features/CSharpTest/GenerateVariable/GenerateVariableTests.cs b/src/Features/CSharpTest/GenerateVariable/GenerateVariableTests.cs index b97543703fe46..4f4ef61cfb30f 100644 --- a/src/Features/CSharpTest/GenerateVariable/GenerateVariableTests.cs +++ b/src/Features/CSharpTest/GenerateVariable/GenerateVariableTests.cs @@ -92,11 +92,11 @@ void Method() } """, [ - string.Format(FeaturesResources.Generate_field_0, "goo"), - string.Format(FeaturesResources.Generate_read_only_field_0, "goo"), - string.Format(FeaturesResources.Generate_property_0, "goo"), - string.Format(FeaturesResources.Generate_local_0, "goo"), - string.Format(FeaturesResources.Generate_parameter_0, "goo"), + string.Format(CodeFixesResources.Generate_field_0, "goo"), + string.Format(CodeFixesResources.Generate_read_only_field_0, "goo"), + string.Format(CodeFixesResources.Generate_property_0, "goo"), + string.Format(CodeFixesResources.Generate_local_0, "goo"), + string.Format(CodeFixesResources.Generate_parameter_0, "goo"), ]); } @@ -114,8 +114,8 @@ void Method() } """, [ - string.Format(FeaturesResources.Generate_field_0, "_goo"), - string.Format(FeaturesResources.Generate_read_only_field_0, "_goo"), + string.Format(CodeFixesResources.Generate_field_0, "_goo"), + string.Format(CodeFixesResources.Generate_read_only_field_0, "_goo"), ]); } @@ -356,7 +356,7 @@ void Method(int i) } } """, -[string.Format(FeaturesResources.Generate_field_0, "goo"), string.Format(FeaturesResources.Generate_property_0, "goo"), string.Format(FeaturesResources.Generate_local_0, "goo"), string.Format(FeaturesResources.Generate_parameter_0, "goo")]); +[string.Format(CodeFixesResources.Generate_field_0, "goo"), string.Format(CodeFixesResources.Generate_property_0, "goo"), string.Format(CodeFixesResources.Generate_local_0, "goo"), string.Format(CodeFixesResources.Generate_parameter_0, "goo")]); } [Fact] @@ -377,7 +377,7 @@ public override void Method(int i) } } """, -[string.Format(FeaturesResources.Generate_field_0, "goo"), string.Format(FeaturesResources.Generate_property_0, "goo"), string.Format(FeaturesResources.Generate_local_0, "goo"), string.Format(FeaturesResources.Generate_parameter_0, "goo"), string.Format(FeaturesResources.Generate_parameter_0_and_overrides_implementations, "goo")]); +[string.Format(CodeFixesResources.Generate_field_0, "goo"), string.Format(CodeFixesResources.Generate_property_0, "goo"), string.Format(CodeFixesResources.Generate_local_0, "goo"), string.Format(CodeFixesResources.Generate_parameter_0, "goo"), string.Format(CodeFixesResources.Generate_parameter_0_and_overrides_implementations, "goo")]); } [Fact] @@ -554,7 +554,7 @@ void Method(out int i) } } """, -[string.Format(FeaturesResources.Generate_field_0, "goo"), string.Format(FeaturesResources.Generate_local_0, "goo"), string.Format(FeaturesResources.Generate_parameter_0, "goo")]); +[string.Format(CodeFixesResources.Generate_field_0, "goo"), string.Format(CodeFixesResources.Generate_local_0, "goo"), string.Format(CodeFixesResources.Generate_parameter_0, "goo")]); } [Fact] @@ -2431,7 +2431,7 @@ static void Main() } } """, -[string.Format(FeaturesResources.Generate_field_0, "p"), string.Format(FeaturesResources.Generate_property_0, "p"), string.Format(FeaturesResources.Generate_local_0, "p"), string.Format(FeaturesResources.Generate_parameter_0, "p")]); +[string.Format(CodeFixesResources.Generate_field_0, "p"), string.Format(CodeFixesResources.Generate_property_0, "p"), string.Format(CodeFixesResources.Generate_local_0, "p"), string.Format(CodeFixesResources.Generate_parameter_0, "p")]); await TestInRegularAndScriptAsync( """ @@ -5320,7 +5320,7 @@ void Goo() #line hidden } """; - await TestExactActionSetOfferedAsync(code, [string.Format(FeaturesResources.Generate_local_0, "Bar"), string.Format(FeaturesResources.Generate_parameter_0, "Bar")]); + await TestExactActionSetOfferedAsync(code, [string.Format(CodeFixesResources.Generate_local_0, "Bar"), string.Format(CodeFixesResources.Generate_parameter_0, "Bar")]); await TestInRegularAndScriptAsync(code, """ @@ -10551,8 +10551,8 @@ public C() } """, [ - string.Format(FeaturesResources.Generate_property_0, "Field"), - string.Format(FeaturesResources.Generate_field_0, "Field"), + string.Format(CodeFixesResources.Generate_property_0, "Field"), + string.Format(CodeFixesResources.Generate_field_0, "Field"), ]); } @@ -10575,8 +10575,8 @@ void Goo() } """, [ - string.Format(FeaturesResources.Generate_property_0, "Field"), - string.Format(FeaturesResources.Generate_field_0, "Field"), + string.Format(CodeFixesResources.Generate_property_0, "Field"), + string.Format(CodeFixesResources.Generate_field_0, "Field"), ]); } @@ -10598,8 +10598,8 @@ internal MyException(int error, int offset, string message) : base(message) } """, [ - string.Format(FeaturesResources.Generate_local_0, "Error", "MyException"), - string.Format(FeaturesResources.Generate_parameter_0, "Error", "MyException"), + string.Format(CodeFixesResources.Generate_local_0, "Error", "MyException"), + string.Format(CodeFixesResources.Generate_parameter_0, "Error", "MyException"), ]); } diff --git a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs index 6500eba0a36e8..ae12d898f9126 100644 --- a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs @@ -391,6 +391,7 @@ private static IMethodSymbol CreateClassConstructor( }); var assignmentStatements = generator.CreateAssignmentStatements( + generator.SyntaxGeneratorInternal, semanticModel, parameters, parameterToPropMap, ImmutableDictionary.Empty, addNullChecks: false, preferThrowExpression: false); diff --git a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs index 651f39a9f512c..5b370bfafccf6 100644 --- a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs @@ -938,6 +938,7 @@ private static IMethodSymbol CreateConstructor( }); var assignmentStatements = generator.CreateAssignmentStatements( + generator.SyntaxGeneratorInternal, semanticModel, parameters, parameterToPropMap, ImmutableDictionary.Empty, addNullChecks: false, preferThrowExpression: false); diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx index af2217d84115d..858998da6e79a 100644 --- a/src/Features/Core/Portable/FeaturesResources.resx +++ b/src/Features/Core/Portable/FeaturesResources.resx @@ -210,27 +210,6 @@ Generate GetHashCode() - - Generate enum member '{0}' - - - Generate constant '{0}' - - - Generate read-only property '{0}' - - - Generate property '{0}' - - - Generate read-only field '{0}' - - - Generate field '{0}' - - - Generate local '{0}' - Generate {0} '{1}' in new file @@ -529,15 +508,6 @@ Unexpected interface member kind: {0} - - Generate abstract property '{0}' - - - Generate abstract method '{0}' - - - Generate method '{0}' - The symbol does not have an icon. @@ -793,9 +763,6 @@ This version used in: {2} Install version '{0}' - - Generate variable '{0}' - Classes @@ -1213,12 +1180,6 @@ This version used in: {2} Target type matches - - Generate parameter '{0}' - - - Generate parameter '{0}' (and overrides/implementations) - in Source (attribute) diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs index 98d9879c14c61..4f76eca26640a 100644 --- a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs +++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.ConstructorDelegatingCodeAction.cs @@ -62,6 +62,7 @@ protected override async Task GetChangedDocumentAsync(CancellationToke factory.IdentifierName(symbolName)); factory.AddAssignmentStatements( + factory.SyntaxGeneratorInternal, semanticModel, parameter, fieldAccess, _addNullChecks, useThrowExpressions, nullCheckStatements, assignStatements); diff --git a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs index e18856e2d5663..e280a6bfb748a 100644 --- a/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs +++ b/src/Features/Core/Portable/GenerateConstructorFromMembers/AbstractGenerateConstructorFromMembersCodeRefactoringProvider.FieldDelegatingCodeAction.cs @@ -45,6 +45,7 @@ protected override async Task GetChangedDocumentAsync(CancellationToke var preferThrowExpression = await _service.PrefersThrowExpressionAsync(_document, cancellationToken).ConfigureAwait(false); var members = factory.CreateMemberDelegatingConstructor( + factory.SyntaxGeneratorInternal, semanticModel, _state.ContainingType.Name, _state.ContainingType, diff --git a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.GenerateNamedType.cs b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.GenerateNamedType.cs index f2bc225c4db8a..6af8d2d605ad7 100644 --- a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.GenerateNamedType.cs +++ b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.GenerateNamedType.cs @@ -219,6 +219,7 @@ private async Task AddFieldDelegatingConstructorAsync( if (!(parameters.Count == 0 && options is { TypeKind: TypeKind.Struct })) { members.AddRange(factory.CreateMemberDelegatingConstructor( + factory.SyntaxGeneratorInternal, _semanticDocument.SemanticModel, DetermineName(), null, parameters.ToImmutable(), Accessibility.Public, parameterToExistingFieldMap.ToImmutable(), diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs index 3fb4cc930394f..41cc1521afdc6 100644 --- a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs @@ -382,7 +382,7 @@ private async Task AddNullCheckStatementAsync( private TStatementSyntax CreateNullCheckStatement(SemanticModel semanticModel, SyntaxGenerator generator, IParameterSymbol parameter, TSimplifierOptions options) => CreateParameterCheckIfStatement( - (TExpressionSyntax)generator.CreateNullCheckExpression(semanticModel, parameter.Name), + (TExpressionSyntax)generator.CreateNullCheckExpression(generator.SyntaxGeneratorInternal, semanticModel, parameter.Name), (TStatementSyntax)generator.CreateThrowArgumentNullExceptionStatement(semanticModel.Compilation, parameter), options); diff --git a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj index ad1ceb9784462..68a99ecbed1c6 100644 --- a/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj +++ b/src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj @@ -147,6 +147,7 @@ + diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf index 1c384ab1dea55..bf612dbd0c45c 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf @@ -820,71 +820,16 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn Našlo se jedno sestavení: {0} - - Generate abstract method '{0}' - Generovat abstraktní metodu {0} - - - - Generate abstract property '{0}' - Generovat abstraktní vlastnost {0} - - Generate comparison operators Vygenerovat operátory porovnání - - Generate constant '{0}' - Generovat konstantu {0} - - - - Generate enum member '{0}' - Generovat člena výčtu {0} - - - - Generate field '{0}' - Generovat pole {0} - - Generate for '{0}' Vygenerovat pro {0} - - Generate method '{0}' - Generovat metodu {0} - - - - Generate parameter '{0}' - Generovat parametr {0} - - - - Generate parameter '{0}' (and overrides/implementations) - Generovat parametr {0} (a přepsání/implementace) - - - - Generate property '{0}' - Generovat vlastnost {0} - - - - Generate read-only field '{0}' - Generovat pole {0} jen pro čtení - - - - Generate read-only property '{0}' - Generovat vlastnost {0} jen pro čtení - - Illegal \ at end of pattern Znak \ na konci vzorku je neplatný. @@ -3885,11 +3830,6 @@ Pokud se specifikátor formátu M použije bez dalších specifikátorů vlastn Generovat GetHashCode() - - Generate local '{0}' - Generovat místní: {0} - - Generate {0} '{1}' in new file Generovat {0} {1} v novém souboru @@ -4555,11 +4495,6 @@ Tato verze se používá zde: {2}. Nainstalovat verzi {0} - - Generate variable '{0}' - Generovat proměnnou {0} - - Classes Třídy diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf index e53dd58413dff..61b2d1258c63b 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf @@ -820,71 +820,16 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d Einzelne Assembly gefunden: {0} - - Generate abstract method '{0}' - Abstrakte Methode „{0}“ generieren - - - - Generate abstract property '{0}' - Abstrakte Eigenschaft „{0}X generieren - - Generate comparison operators Vergleichsoperatoren generieren - - Generate constant '{0}' - Konstante „{0}“ generieren - - - - Generate enum member '{0}' - Aufzählungselement „{0}“ generieren - - - - Generate field '{0}' - Feld „{0}“ generieren - - Generate for '{0}' Für "{0}" generieren - - Generate method '{0}' - Methode „{0}“ generieren - - - - Generate parameter '{0}' - Parameter "{0}" generieren - - - - Generate parameter '{0}' (and overrides/implementations) - Parameter "{0}" (und Außerkraftsetzungen/Implementierungen) generieren - - - - Generate property '{0}' - Eigenschaft „{0}“ generieren - - - - Generate read-only field '{0}' - Schreibgeschütztes Feld „{0}“ generieren - - - - Generate read-only property '{0}' - Schreibgeschützte Eigenschaft „{0}“ generieren - - Illegal \ at end of pattern Nicht zulässiges \-Zeichen am Ende des Musters. @@ -3885,11 +3830,6 @@ Bei Verwendung des Formatbezeichners "M" ohne weitere benutzerdefinierte Formatb "GetHashCode()" generieren - - Generate local '{0}' - Lokales "{0}" generieren - - Generate {0} '{1}' in new file {0}-Objekt "{1}" in neuer Datei generieren @@ -4555,11 +4495,6 @@ Diese Version wird verwendet in: {2} Version "{0}" installieren - - Generate variable '{0}' - Variable "{0}" generieren - - Classes Klassen diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf index 8d854dbb4a00e..6816a6c07f18f 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf @@ -820,71 +820,16 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa Se encontró un solo ensamblado: "{0}" - - Generate abstract method '{0}' - Generar método abstracto "{0}" - - - - Generate abstract property '{0}' - Generar propiedad abstracta "{0}" - - Generate comparison operators Generar operadores de comparación - - Generate constant '{0}' - Generar constante "{0}" - - - - Generate enum member '{0}' - Generar miembro de enumeración "{0}" - - - - Generate field '{0}' - Generar campo "{0}" - - Generate for '{0}' Generar para "{0}" - - Generate method '{0}' - Generar método "{0}" - - - - Generate parameter '{0}' - Generar el parámetro "{0}" - - - - Generate parameter '{0}' (and overrides/implementations) - Generar el parámetro "{0}" (y reemplazos/implementaciones) - - - - Generate property '{0}' - Generar propiedad "{0}" - - - - Generate read-only field '{0}' - Generar un campo de sólo lectura "{0}" - - - - Generate read-only property '{0}' - Generar propiedad de solo lectura "{0}" - - Illegal \ at end of pattern \ no válido al final del modelo @@ -3885,11 +3830,6 @@ Si el especificador de formato "M" se usa sin otros especificadores de formato p Generar "GetHashCode()" - - Generate local '{0}' - Generar la variable local '{0}' - - Generate {0} '{1}' in new file Generar {0} '{1}' en archivo nuevo @@ -4555,11 +4495,6 @@ Esta versión se utiliza en: {2} Instalar la versión '{0}' - - Generate variable '{0}' - Generar variable '{0}' - - Classes Clases diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf index 51e9b1ee8111e..25845859a68dd 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf @@ -820,71 +820,16 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai Un seul assembly trouvé : '{0}' - - Generate abstract method '{0}' - Générer la méthode abstraite '{0}' - - - - Generate abstract property '{0}' - Générer la propriété abstraite '{0}' - - Generate comparison operators Générer des opérateurs de comparaison - - Generate constant '{0}' - Générer une constante '{0}' - - - - Generate enum member '{0}' - Générer le membre enum '{0}' - - - - Generate field '{0}' - Générer le champ '{0}' - - Generate for '{0}' Générer pour '{0}' - - Generate method '{0}' - Générer la méthode '{0}' - - - - Generate parameter '{0}' - Générer le paramètre '{0}' - - - - Generate parameter '{0}' (and overrides/implementations) - Générer le paramètre '{0}' (et les substitutions/implémentations) - - - - Generate property '{0}' - Générer la propriété '{0}' - - - - Generate read-only field '{0}' - Générer le champ en lecture seule '{0}' - - - - Generate read-only property '{0}' - Générer la propriété en lecture seule '{0}' - - Illegal \ at end of pattern Caractère \ non autorisé à la fin du modèle @@ -3885,11 +3830,6 @@ Si le spécificateur de format "M" est utilisé sans autres spécificateurs de f Générer GetHashCode() - - Generate local '{0}' - Générer le '{0}' local - - Generate {0} '{1}' in new file Générer {0} '{1}' dans un nouveau fichier @@ -4555,11 +4495,6 @@ Version utilisée dans : {2} Installer la version '{0}' - - Generate variable '{0}' - Générer la variable '{0}' - - Classes Classes diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf index a302aa093cf04..6c1e109e27aad 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf @@ -820,71 +820,16 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa È stato trovato un solo assembly: '{0}' - - Generate abstract method '{0}' - Genera il metodo astratto '{0}' - - - - Generate abstract property '{0}' - Genera la proprietà astratta '{0}' - - Generate comparison operators Genera gli operatori di confronto - - Generate constant '{0}' - Genera la costante '{0}' - - - - Generate enum member '{0}' - Genera il membro di enumerazione '{0}' - - - - Generate field '{0}' - Genera il campo '{0}' - - Generate for '{0}' Genera per '{0}' - - Generate method '{0}' - Genera il metodo '{0}' - - - - Generate parameter '{0}' - Generare il parametro '{0}' - - - - Generate parameter '{0}' (and overrides/implementations) - Generare il parametro '{0}' (e override/implementazioni) - - - - Generate property '{0}' - Genera la proprietà '{0}' - - - - Generate read-only field '{0}' - Genera il campo di sola lettura '{0}' - - - - Generate read-only property '{0}' - Genera la proprietà di sola lettura '{0}' - - Illegal \ at end of pattern Carattere \ non valido alla fine del criterio @@ -3885,11 +3830,6 @@ Se l'identificatore di formato "M" viene usato senza altri identificatori di for Genera GetHashCode() - - Generate local '{0}' - Genera l'elemento '{0}' locale - - Generate {0} '{1}' in new file Genera l'elemento {0} '{1}' nel nuovo file @@ -4555,11 +4495,6 @@ Questa versione è usata {2} Installa la versione '{0}' - - Generate variable '{0}' - Genera la variabile '{0}' - - Classes Classi diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf index e7b72b287eb59..a7f89b00d1352 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf @@ -820,71 +820,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 1 つのアセンブリが見つかりました: '{0}' - - Generate abstract method '{0}' - 抽象メソッド '{0}' を生成する - - - - Generate abstract property '{0}' - 抽象プロパティ '{0}' を生成する - - Generate comparison operators 比較演算子の生成 - - Generate constant '{0}' - 定数 '{0}' を生成する - - - - Generate enum member '{0}' - 列挙型メンバー '{0}' を生成する - - - - Generate field '{0}' - フィールド '{0}' を生成する - - Generate for '{0}' '{0}' の生成 - - Generate method '{0}' - メソッド '{0}' を生成する - - - - Generate parameter '{0}' - パラメーター '{0}' の生成 - - - - Generate parameter '{0}' (and overrides/implementations) - パラメーター '{0}' の生成 (およびオーバーライド/実装) - - - - Generate property '{0}' - プロパティ '{0}' を生成する - - - - Generate read-only field '{0}' - 読み取り専用フィールド '{0}' を生成する - - - - Generate read-only property '{0}' - 読み取り専用プロパティ '{0}' を生成する - - Illegal \ at end of pattern 無効\末尾のパターン @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's GetHashCode() を生成する - - Generate local '{0}' - ローカルの '{0}' を生成します - - Generate {0} '{1}' in new file 新しいファイルに {0} '{1}' を生成する @@ -4555,11 +4495,6 @@ This version used in: {2} バージョン '{0}' のインストール - - Generate variable '{0}' - 変数 '{0}' を生成する - - Classes クラス diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf index e123b3e9a10e4..db9f00c3a3165 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf @@ -820,71 +820,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 단일 어셈블리를 찾았습니다. '{0}' - - Generate abstract method '{0}' - '{0}' 요약 메서드 생성 - - - - Generate abstract property '{0}' - '{0}' 요약 속성 생성 - - Generate comparison operators 비교 연산자 생성 - - Generate constant '{0}' - '{0}' 상수 생성 - - - - Generate enum member '{0}' - '{0}' 열거형 멤버 생성 - - - - Generate field '{0}' - '{0}' 필드 생성 - - Generate for '{0}' '{0}'에 대해 생성 - - Generate method '{0}' - ‘{0}’ 메서드 생성 - - - - Generate parameter '{0}' - '{0}' 매개 변수 생성 - - - - Generate parameter '{0}' (and overrides/implementations) - '{0}' 매개 변수(및 재정의/구현) 생성 - - - - Generate property '{0}' - '{0}' 속성 생성 - - - - Generate read-only field '{0}' - '{0}' 읽기 전용 필드 생성 - - - - Generate read-only property '{0}' - '{0}' 읽기 전용 속성 생성 - - Illegal \ at end of pattern 패턴 끝에 \를 사용할 수 없습니다. @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's GetHashCode() 생성 - - Generate local '{0}' - '{0}' 로컬을 생성합니다. - - Generate {0} '{1}' in new file 새 파일에서 {0} '{1}' 생성 @@ -4555,11 +4495,6 @@ This version used in: {2} '{0}' 버전 설치 - - Generate variable '{0}' - '{0}' 변수 생성 - - Classes 클래스 diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf index b0b5db3130350..9fdb1d8f52d26 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf @@ -820,71 +820,16 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k Znaleziono pojedynczy zestaw: „{0}” - - Generate abstract method '{0}' - Generuj metodę abstrakcyjną „{0}” - - - - Generate abstract property '{0}' - Generuj właściwość abstrakcyjną „{0}” - - Generate comparison operators Generuj operatory porównania - - Generate constant '{0}' - Generuj stałą „{0}” - - - - Generate enum member '{0}' - Generuj składową wyliczenia „{0}” - - - - Generate field '{0}' - Generuj pole „{0}” - - Generate for '{0}' Wygeneruj dla elementu „{0}” - - Generate method '{0}' - Generuj metodę „{0}” - - - - Generate parameter '{0}' - Generuj parametr „{0}” - - - - Generate parameter '{0}' (and overrides/implementations) - Generowanie parametru „{0}” (i przesłonięć/implementacji) - - - - Generate property '{0}' - Generuj właściwość „{0}” - - - - Generate read-only field '{0}' - Generuj pole tylko do odczytu „{0}” - - - - Generate read-only property '{0}' - Generuj właściwość tylko do odczytu „{0}” - - Illegal \ at end of pattern Niedozwolony znak \ na końcu wzorca @@ -3885,11 +3830,6 @@ Jeśli specyfikator formatu „M” jest używany bez innych niestandardowych sp Generuj element GetHashCode() - - Generate local '{0}' - Generuj lokalny element „{0}” - - Generate {0} '{1}' in new file Generuj element {0} „{1}” w nowym pliku @@ -4555,11 +4495,6 @@ Ta wersja jest używana wersja: {2} Zainstaluj wersję „{0}” - - Generate variable '{0}' - Generuj zmienną „{0}” - - Classes Klasy diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf index 672f0e5312e09..2a74c409b230a 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf @@ -820,71 +820,16 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess Foi encontrado um assembly: '{0}' - - Generate abstract method '{0}' - Gerar o método abstrato '{0}' - - - - Generate abstract property '{0}' - Gerar a propriedade abstrata '{0}' - - Generate comparison operators Gerar operadores de comparação - - Generate constant '{0}' - Gerar constante '{0}' - - - - Generate enum member '{0}' - Gerar o membro de enumeração '{0}' - - - - Generate field '{0}' - Gerar campo '{0}' - - Generate for '{0}' Gerar para '{0}' - - Generate method '{0}' - Gerar método '{0}' - - - - Generate parameter '{0}' - Gerar o parâmetro '{0}' - - - - Generate parameter '{0}' (and overrides/implementations) - Gerar o parâmetro '{0}' (e as substituições/implementações) - - - - Generate property '{0}' - Gerar propriedade '{0}' - - - - Generate read-only field '{0}' - Gerar o campo somente leitura '{0}' - - - - Generate read-only property '{0}' - Gerar a propriedade somente leitura '{0}' - - Illegal \ at end of pattern \ ilegal no final do padrão @@ -3885,11 +3830,6 @@ Se o especificador de formato "M" for usado sem outros especificadores de format Gerar GetHashCode() - - Generate local '{0}' - Gerar local '{0}' - - Generate {0} '{1}' in new file Gerar {0} '{1}' no novo arquivo @@ -4555,11 +4495,6 @@ Essa versão é usada no: {2} Instalar a versão '{0}' - - Generate variable '{0}' - Gerar variável '{0}' - - Classes Classes diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf index c29eba611742a..cc8dac33ef5b2 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf @@ -820,71 +820,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma Найдена одна сборка: "{0}" - - Generate abstract method '{0}' - Создать абстрактный метод "{0}" - - - - Generate abstract property '{0}' - Создать абстрактное свойство "{0}" - - Generate comparison operators Создать операторы сравнения - - Generate constant '{0}' - Создать константу "{0}" - - - - Generate enum member '{0}' - Создать элемент перечисления "{0}" - - - - Generate field '{0}' - Создать поле "{0}" - - Generate for '{0}' Создать для "{0}" - - Generate method '{0}' - Создать метод "{0}" - - - - Generate parameter '{0}' - Создать параметр "{0}" - - - - Generate parameter '{0}' (and overrides/implementations) - Создать параметр "{0}" (а также переопределения или реализации) - - - - Generate property '{0}' - Создать свойство "{0}" - - - - Generate read-only field '{0}' - Создать поле только для чтения "{0}" - - - - Generate read-only property '{0}' - Создать свойство только для чтения "{0}" - - Illegal \ at end of pattern Недопустимый символ "\" в конце шаблона @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's Создать "GetHashCode()" - - Generate local '{0}' - Создайте локальную переменную "{0}" - - Generate {0} '{1}' in new file Создать {0} "{1}" в новом файле @@ -4555,11 +4495,6 @@ This version used in: {2} Установить версию "{0}" - - Generate variable '{0}' - Создать переменную "{0}" - - Classes Классы diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf index 77fc6ac3412b7..4eaebdf558f48 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf @@ -820,71 +820,16 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be Tek bütünleştirilmiş kod bulundu: '{0}' - - Generate abstract method '{0}' - '{0}' soyut metodunu üret - - - - Generate abstract property '{0}' - '{0}' soyut özelliğini üret - - Generate comparison operators Karşılaştırma işleçlerini oluştur - - Generate constant '{0}' - '{0}' sabitini üret - - - - Generate enum member '{0}' - '{0}' sabit listesi üyesini üret - - - - Generate field '{0}' - '{0}' alanını üret - - Generate for '{0}' '{0}' için oluştur - - Generate method '{0}' - '{0}' metodunu üret - - - - Generate parameter '{0}' - '{0}' parametresini üret - - - - Generate parameter '{0}' (and overrides/implementations) - '{0}' parametresini (ve geçersiz kılmaları/uygulamaları) üret - - - - Generate property '{0}' - '{0}' özelliğini üret - - - - Generate read-only field '{0}' - '{0}' salt okunur alanını üret - - - - Generate read-only property '{0}' - '{0}' salt okunur özelliğini üret - - Illegal \ at end of pattern Yasadışı \ model sonunda @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's GetHashCode() oluştur - - Generate local '{0}' - Yerel '{0}' üretin - - Generate {0} '{1}' in new file Yeni dosyada {0} '{1}' oluştur @@ -4555,11 +4495,6 @@ Bu sürüm şurada kullanılır: {2} '{0}' sürümünü yükle - - Generate variable '{0}' - '{0}' değişkenini oluştur - - Classes Sınıflar diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf index 458372994851b..af2d724708943 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf @@ -820,71 +820,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 找到单个程序集: "{0}" - - Generate abstract method '{0}' - 生成抽象方法“{0}” - - - - Generate abstract property '{0}' - 生成抽象属性“{0}” - - Generate comparison operators 生成比较运算符 - - Generate constant '{0}' - 生成常数“{0}” - - - - Generate enum member '{0}' - 生成枚举成员“{0}” - - - - Generate field '{0}' - 生成字段“{0}” - - Generate for '{0}' 为 "{0}" 生成 - - Generate method '{0}' - 生成方法“{0}” - - - - Generate parameter '{0}' - 生成参数 "{0}" - - - - Generate parameter '{0}' (and overrides/implementations) - 生成参数 {0}(和重写/实现) - - - - Generate property '{0}' - 生成属性“{0}” - - - - Generate read-only field '{0}' - 生成只读字段“{0}” - - - - Generate read-only property '{0}' - 生成只读属性“{0}” - - Illegal \ at end of pattern 模式末尾的 \ 非法 @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's 生成 GetHashCode() - - Generate local '{0}' - 生成本地“{0}” - - Generate {0} '{1}' in new file 在新文件中生成 {0}“{1}” @@ -4555,11 +4495,6 @@ This version used in: {2} 安装版本“{0}” - - Generate variable '{0}' - 生成变量 {0} - - Classes 类 diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf index be8ca9aa88290..889b940873de8 100644 --- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf +++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf @@ -820,71 +820,16 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma 找到單一組件: '{0}' - - Generate abstract method '{0}' - 產生抽象方法 '{0}' - - - - Generate abstract property '{0}' - 產生抽象屬性 '{0}' - - Generate comparison operators 產生比較運算子 - - Generate constant '{0}' - 產生常數 '{0}' - - - - Generate enum member '{0}' - 產生列舉成員 '{0}' - - - - Generate field '{0}' - 產生欄位 '{0}' - - Generate for '{0}' 為 '{0}' 產生 - - Generate method '{0}' - 產生方法 '{0}' - - - - Generate parameter '{0}' - 產生參數 '{0}' - - - - Generate parameter '{0}' (and overrides/implementations) - 產生參數 '{0}' (以及覆寫/實作) - - - - Generate property '{0}' - 產生屬性 '{0}' - - - - Generate read-only field '{0}' - 產生唯讀欄位 '{0}' - - - - Generate read-only property '{0}' - 產生唯讀屬性 '{0}' - - Illegal \ at end of pattern 模式結尾使用 \ 不符合格式規定 @@ -3885,11 +3830,6 @@ If the "M" format specifier is used without other custom format specifiers, it's 產生 GetHashCode() - - Generate local '{0}' - 產生區域 '{0}' - - Generate {0} '{1}' in new file 在新檔案中產生 {0} '{1}' @@ -4555,11 +4495,6 @@ This version used in: {2} 安裝 '{0}' 版 - - Generate variable '{0}' - 產生變數 '{0}' - - Classes 類別 diff --git a/src/Features/VisualBasic/Portable/VBFeaturesResources.resx b/src/Features/VisualBasic/Portable/VBFeaturesResources.resx index 6d123e4e8801c..310eaf5dbd866 100644 --- a/src/Features/VisualBasic/Portable/VBFeaturesResources.resx +++ b/src/Features/VisualBasic/Portable/VBFeaturesResources.resx @@ -950,12 +950,6 @@ Sub(<parameterList>) <statement> NameOf function - - Generate narrowing conversion in '{0}' - - - Generate widening conversion in '{0}' - Try block {Locked="Try"} "Try" is a VB keyword and should not be localized. diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.cs.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.cs.xlf index 840fc42e7a34f..931bbf61f7e04 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.cs.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.cs.xlf @@ -1462,16 +1462,6 @@ Sub(<seznam_parametrů>) <výraz> Funkce NameOf - - Generate narrowing conversion in '{0}' - Generovat zužující převod v {0} - - - - Generate widening conversion in '{0}' - Generovat rozšiřující konverzi v {0} - - Try block Blok Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.de.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.de.xlf index 6d3a48c606c0c..2a4ed298eeb31 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.de.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.de.xlf @@ -1462,16 +1462,6 @@ Sub(<Parameterliste>) <Ausdruck> NameOf-Funktion - - Generate narrowing conversion in '{0}' - Einschränkende Konvertierung in "{0}" generieren - - - - Generate widening conversion in '{0}' - Erweiternde Konvertierung in "{0}" generieren - - Try block Try-Block diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf index eee87c7baf6e9..6d0d9953583e4 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.es.xlf @@ -1462,16 +1462,6 @@ Sub(<listaDeParámetros>) <instrucción>wo laopo fuke Función NameOf - - Generate narrowing conversion in '{0}' - Generar conversión de restricción en "{0}" - - - - Generate widening conversion in '{0}' - Generar conversión de ampliación en "{0}" - - Try block Bloque Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.fr.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.fr.xlf index a95b6b7cea7d3..44a54bf49d7d7 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.fr.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.fr.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> Fonction NameOf - - Generate narrowing conversion in '{0}' - Générer une conversion restrictive dans '{0}' - - - - Generate widening conversion in '{0}' - Générer une conversation étendue dans '{0}' - - Try block Bloc Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf index d42d0763ad76b..dc38e5874667a 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.it.xlf @@ -1462,16 +1462,6 @@ Sub(<elencoParametri>) <istruzione> Funzione NameOf - - Generate narrowing conversion in '{0}' - Genera la conversione che supporta un minor numero di dati in '{0}' - - - - Generate widening conversion in '{0}' - Genera la conversione che supporta un maggior numero di dati in '{0}' - - Try block blocco Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ja.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ja.xlf index 7a0990edf1b28..9cbf48911c113 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ja.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ja.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> NameOf 関数 - - Generate narrowing conversion in '{0}' - '{0}' で縮小変換を生成する - - - - Generate widening conversion in '{0}' - '{0}' で拡大変換を生成する - - Try block Try ブロック diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ko.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ko.xlf index de88d3d832bab..b42832f0e0917 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ko.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ko.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> 함수 이름 - - Generate narrowing conversion in '{0}' - '{0}'에서 축소 변환 생성 - - - - Generate widening conversion in '{0}' - '{0}'에서 확대 변환 생성 - - Try block Try 블록 diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pl.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pl.xlf index 90add374cb980..b81329c2ca0bd 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pl.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pl.xlf @@ -1462,16 +1462,6 @@ Sub(<listaParametrów>) <instrukcja> Funkcja NameOf - - Generate narrowing conversion in '{0}' - Generuj konwersję zawężającą w elemencie „{0}” - - - - Generate widening conversion in '{0}' - Generuj konwersję rozszerzającą w elemencie „{0}” - - Try block Blok Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf index 5e2f0a2a4d471..69dd91cda7e14 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.pt-BR.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> Função NameOf - - Generate narrowing conversion in '{0}' - Gerar conversão de restrição no '{0}' - - - - Generate widening conversion in '{0}' - Gerar conversão de expansão no '{0}' - - Try block Bloco Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ru.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ru.xlf index 91d69de03f6e9..d1a1cd855b1f8 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ru.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.ru.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> Имя функции - - Generate narrowing conversion in '{0}' - Создайте сужающее преобразование в "{0}" - - - - Generate widening conversion in '{0}' - Создайте расширяющееся преобразование в "{0}" - - Try block Блок Try diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf index cd8eaf046e561..7e7a4e90fa42b 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.tr.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> İşlev adı - - Generate narrowing conversion in '{0}' - '{0}' öğesinde daraltma dönüştürmesi oluştur - - - - Generate widening conversion in '{0}' - '{0}' öğesinde genişletme dönüşümü oluştur - - Try block Try bloğu diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf index d539438752ab0..36c5c449da042 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hans.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> NameOf 函数 - - Generate narrowing conversion in '{0}' - 在“{0}”中生成收缩转换 - - - - Generate widening conversion in '{0}' - 在“{0}”中生成扩大转换 - - Try block Try 块 diff --git a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf index 40d3a0c44244f..e3089b0028533 100644 --- a/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf +++ b/src/Features/VisualBasic/Portable/xlf/VBFeaturesResources.zh-Hant.xlf @@ -1462,16 +1462,6 @@ Sub(<parameterList>) <statement> NameOf 函式 - - Generate narrowing conversion in '{0}' - 在 '{0}' 中產生縮小轉換 - - - - Generate widening conversion in '{0}' - 在 '{0}' 中產生放大轉換 - - Try block Try 區塊 diff --git a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs index 1a5a3fe8f5d77..95dc4d1a23c5d 100644 --- a/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs +++ b/src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs @@ -41,9 +41,8 @@ public CSharpSyntaxGenerator() internal override SyntaxTrivia ElasticMarker => SyntaxFactory.ElasticMarker; - internal override bool RequiresExplicitImplementationForInterfaceMembers => false; - - internal override SyntaxGeneratorInternal SyntaxGeneratorInternal => CSharpSyntaxGeneratorInternal.Instance; + internal override SyntaxGeneratorInternal SyntaxGeneratorInternal + => CSharpSyntaxGeneratorInternal.Instance; internal override SyntaxTrivia Whitespace(string text) => SyntaxFactory.Whitespace(text); @@ -3114,8 +3113,6 @@ public override SyntaxNode ThrowStatement(SyntaxNode? expression = null) public override SyntaxNode ThrowExpression(SyntaxNode expression) => SyntaxFactory.ThrowExpression((ExpressionSyntax)expression); - internal override bool SupportsThrowExpression() => true; - public override SyntaxNode IfStatement(SyntaxNode condition, IEnumerable trueStatements, IEnumerable? falseStatements = null) { if (falseStatements == null) diff --git a/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj b/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj index 92415ddba7007..db13a67933d7b 100644 --- a/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj +++ b/src/Workspaces/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Workspaces.csproj @@ -59,6 +59,9 @@ + + + \ No newline at end of file diff --git a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs index 6e36eaae9ba34..70da68cf4cf59 100644 --- a/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs +++ b/src/Workspaces/Core/Portable/Editing/SyntaxGenerator.cs @@ -33,13 +33,17 @@ public abstract class SyntaxGenerator : ILanguageService { public static readonly SyntaxRemoveOptions DefaultRemoveOptions = SyntaxRemoveOptions.KeepUnbalancedDirectives | SyntaxRemoveOptions.AddElasticMarker; + internal abstract SyntaxGeneratorInternal SyntaxGeneratorInternal { get; } + internal SyntaxTrivia CarriageReturnLineFeed => this.SyntaxGeneratorInternal.CarriageReturnLineFeed; internal SyntaxTrivia ElasticCarriageReturnLineFeed => this.SyntaxGeneratorInternal.ElasticCarriageReturnLineFeed; internal abstract SyntaxTrivia ElasticMarker { get; } - internal abstract bool RequiresExplicitImplementationForInterfaceMembers { get; } - internal ISyntaxFacts SyntaxFacts => SyntaxGeneratorInternal.SyntaxFacts; - internal abstract SyntaxGeneratorInternal SyntaxGeneratorInternal { get; } + internal bool RequiresExplicitImplementationForInterfaceMembers + => this.SyntaxGeneratorInternal.RequiresExplicitImplementationForInterfaceMembers; + + internal ISyntaxFacts SyntaxFacts + => SyntaxGeneratorInternal.SyntaxFacts; internal abstract SyntaxTrivia Whitespace(string text); @@ -1592,7 +1596,8 @@ internal SyntaxNode YieldReturnStatement(SyntaxNode expression) /// /// True if can be used /// - internal abstract bool SupportsThrowExpression(); + internal bool SupportsThrowExpression() + => this.SyntaxGeneratorInternal.SupportsThrowExpression(); /// /// if the language requires a diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/IPropertySymbolExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/IPropertySymbolExtensions.cs deleted file mode 100644 index 1f423e23f8998..0000000000000 --- a/src/Workspaces/Core/Portable/Shared/Extensions/IPropertySymbolExtensions.cs +++ /dev/null @@ -1,20 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -using System; -using System.Collections.Immutable; -using System.Linq; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CodeGeneration; - -namespace Microsoft.CodeAnalysis.Shared.Extensions; - -internal static partial class IPropertySymbolExtensions -{ - public static bool IsWritableInConstructor(this IPropertySymbol property) - => property.SetMethod != null || ContainsBackingField(property); - - private static bool ContainsBackingField(IPropertySymbol property) - => property.GetBackingFieldIfAny() != null; -} diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs index 98201956fdba4..a27ff01a2706a 100644 --- a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs +++ b/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs @@ -2,9 +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.Collections.Generic; using System.Collections.Immutable; -using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Threading; using Microsoft.CodeAnalysis; @@ -174,40 +172,6 @@ from member in baseType.GetMembers(constructedInterfaceMember.Name).OfType availableTypeParameters) - { - return type?.RemoveUnavailableTypeParameters(compilation, availableTypeParameters.Select(t => t.Name).ToSet()); - } - - [return: NotNullIfNotNull(parameterName: nameof(type))] - private static ITypeSymbol? RemoveUnavailableTypeParameters( - this ITypeSymbol? type, - Compilation compilation, - ISet availableTypeParameterNames) - { - return type?.Accept(new UnavailableTypeParameterRemover(compilation, availableTypeParameterNames)); - } - - [return: NotNullIfNotNull(parameterName: nameof(type))] - public static ITypeSymbol? RemoveAnonymousTypes( - this ITypeSymbol? type, - Compilation compilation) - { - return type?.Accept(new AnonymousTypeRemover(compilation)); - } - - [return: NotNullIfNotNull(parameterName: nameof(type))] - public static ITypeSymbol? RemoveUnnamedErrorTypes( - this ITypeSymbol? type, - Compilation compilation) - { - return type?.Accept(new UnnamedErrorTypeRemover(compilation)); - } - public static bool CanBeEnumerated(this ITypeSymbol type) { // Type itself is IEnumerable/IEnumerable diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions.cs index 89c44e9d4a0c0..991cd1db6866a 100644 --- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions.cs +++ b/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions.cs @@ -40,271 +40,6 @@ public static IMethodSymbol CreateBaseDelegatingConstructor( : factory.CreateArguments(constructor.Parameters)); } - public static ImmutableArray CreateMemberDelegatingConstructor( - this SyntaxGenerator factory, - SemanticModel semanticModel, - string typeName, - INamedTypeSymbol? containingType, - ImmutableArray parameters, - Accessibility accessibility, - ImmutableDictionary? parameterToExistingMemberMap, - ImmutableDictionary? parameterToNewMemberMap, - bool addNullChecks, - bool preferThrowExpression, - bool generateProperties, - bool isContainedInUnsafeType) - { - var newMembers = generateProperties - ? CreatePropertiesForParameters(parameters, parameterToNewMemberMap, isContainedInUnsafeType) - : CreateFieldsForParameters(parameters, parameterToNewMemberMap, isContainedInUnsafeType); - var statements = factory.CreateAssignmentStatements( - semanticModel, parameters, parameterToExistingMemberMap, parameterToNewMemberMap, - addNullChecks, preferThrowExpression).SelectAsArray( - s => s.WithAdditionalAnnotations(Simplifier.Annotation)); - - var constructor = CodeGenerationSymbolFactory.CreateConstructorSymbol( - attributes: default, - accessibility: accessibility, - modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameters.Any(static p => p.RequiresUnsafeModifier())), - typeName: typeName, - parameters: parameters, - statements: statements, - thisConstructorArguments: ShouldGenerateThisConstructorCall(containingType, parameterToExistingMemberMap) - ? [] - : default); - - return newMembers.Concat(constructor); - } - - private static bool ShouldGenerateThisConstructorCall( - INamedTypeSymbol? containingType, - IDictionary? parameterToExistingFieldMap) - { - if (containingType?.TypeKind == TypeKind.Struct) - { - // Special case. If we're generating a struct constructor, then we'll need - // to initialize all fields in the struct, not just the ones we're creating. - // If there is any field or auto-property not being set by a parameter, we - // call the default constructor. - - return containingType.GetMembers() - .OfType() - .Where(field => !field.IsStatic) - .Select(field => field.AssociatedSymbol ?? field) - .Except(parameterToExistingFieldMap?.Values ?? []) - .Any(); - } - - return false; - } - - public static ImmutableArray CreateFieldsForParameters( - ImmutableArray parameters, ImmutableDictionary? parameterToNewFieldMap, bool isContainedInUnsafeType) - { - using var _ = ArrayBuilder.GetInstance(out var result); - foreach (var parameter in parameters) - { - // For non-out parameters, create a field and assign the parameter to it. - if (parameter.RefKind != RefKind.Out && - TryGetValue(parameterToNewFieldMap, parameter.Name, out var fieldName)) - { - result.Add(CodeGenerationSymbolFactory.CreateFieldSymbol( - attributes: default, - accessibility: Accessibility.Private, - modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameter.RequiresUnsafeModifier()), - type: parameter.Type, - name: fieldName)); - } - } - - return result.ToImmutableAndClear(); - } - - public static ImmutableArray CreatePropertiesForParameters( - ImmutableArray parameters, ImmutableDictionary? parameterToNewPropertyMap, bool isContainedInUnsafeType) - { - using var _ = ArrayBuilder.GetInstance(out var result); - foreach (var parameter in parameters) - { - // For non-out parameters, create a property and assign the parameter to it. - if (parameter.RefKind != RefKind.Out && - TryGetValue(parameterToNewPropertyMap, parameter.Name, out var propertyName)) - { - result.Add(CodeGenerationSymbolFactory.CreatePropertySymbol( - attributes: default, - accessibility: Accessibility.Public, - modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameter.RequiresUnsafeModifier()), - type: parameter.Type, - refKind: RefKind.None, - explicitInterfaceImplementations: [], - name: propertyName, - parameters: [], - getMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol( - attributes: default, - accessibility: default, - statements: default), - setMethod: null)); - } - } - - return result.ToImmutableAndClear(); - } - - private static bool TryGetValue(IDictionary? dictionary, string key, [NotNullWhen(true)] out string? value) - { - value = null; - return - dictionary != null && - dictionary.TryGetValue(key, out value); - } - - private static bool TryGetValue(IDictionary? dictionary, string key, [NotNullWhen(true)] out string? value) - { - value = null; - if (dictionary != null && dictionary.TryGetValue(key, out var symbol)) - { - value = symbol.Name; - return true; - } - - return false; - } - - public static SyntaxNode CreateThrowArgumentNullExpression(this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) - => factory.ThrowExpression(CreateNewArgumentNullException(factory, compilation, parameter)); - - private static SyntaxNode CreateNewArgumentNullException(SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) - { - var type = compilation.GetTypeByMetadataName(typeof(ArgumentNullException).FullName!); - Contract.ThrowIfNull(type); - return factory.ObjectCreationExpression(type, - factory.NameOfExpression( - factory.IdentifierName(parameter.Name))).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation); - } - - public static SyntaxNode CreateNullCheckAndThrowStatement( - this SyntaxGenerator factory, - SemanticModel semanticModel, - IParameterSymbol parameter) - { - var condition = factory.CreateNullCheckExpression(semanticModel, parameter.Name); - var throwStatement = factory.CreateThrowArgumentNullExceptionStatement(semanticModel.Compilation, parameter); - - // generates: if (s is null) { throw new ArgumentNullException(nameof(s)); } - return factory.IfStatement(condition, [throwStatement]); - } - - public static SyntaxNode CreateThrowArgumentNullExceptionStatement(this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) - => factory.ThrowStatement(CreateNewArgumentNullException(factory, compilation, parameter)); - - public static SyntaxNode CreateNullCheckExpression(this SyntaxGenerator factory, SemanticModel semanticModel, string identifierName) - { - var identifier = factory.IdentifierName(identifierName); - var nullExpr = factory.NullLiteralExpression(); - var condition = factory.SyntaxGeneratorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options) - ? factory.SyntaxGeneratorInternal.IsPatternExpression(identifier, factory.SyntaxGeneratorInternal.ConstantPattern(nullExpr)) - : factory.ReferenceEqualsExpression(identifier, nullExpr); - return condition; - } - - public static ImmutableArray CreateAssignmentStatements( - this SyntaxGenerator factory, - SemanticModel semanticModel, - ImmutableArray parameters, - IDictionary? parameterToExistingFieldMap, - IDictionary? parameterToNewFieldMap, - bool addNullChecks, - bool preferThrowExpression) - { - var nullCheckStatements = ArrayBuilder.GetInstance(); - var assignStatements = ArrayBuilder.GetInstance(); - - foreach (var parameter in parameters) - { - var refKind = parameter.RefKind; - var parameterType = parameter.Type; - var parameterName = parameter.Name; - - if (refKind == RefKind.Out) - { - // If it's an out param, then don't create a field for it. Instead, assign - // the default value for that type (i.e. "default(...)") to it. - var assignExpression = factory.AssignmentStatement( - factory.IdentifierName(parameterName), - factory.DefaultExpression(parameterType)); - var statement = factory.ExpressionStatement(assignExpression); - assignStatements.Add(statement); - } - else - { - // For non-out parameters, create a field and assign the parameter to it. - // TODO: I'm not sure that's what we really want for ref parameters. - if (TryGetValue(parameterToExistingFieldMap, parameterName, out var fieldName) || - TryGetValue(parameterToNewFieldMap, parameterName, out fieldName)) - { - var fieldAccess = factory.MemberAccessExpression(factory.ThisExpression(), factory.IdentifierName(fieldName)) - .WithAdditionalAnnotations(Simplifier.Annotation); - - factory.AddAssignmentStatements( - semanticModel, parameter, fieldAccess, - addNullChecks, preferThrowExpression, - nullCheckStatements, assignStatements); - } - } - } - - return nullCheckStatements.ToImmutableAndFree().Concat(assignStatements.ToImmutableAndFree()); - } - - public static void AddAssignmentStatements( - this SyntaxGenerator factory, - SemanticModel semanticModel, - IParameterSymbol parameter, - SyntaxNode fieldAccess, - bool addNullChecks, - bool preferThrowExpression, - ArrayBuilder nullCheckStatements, - ArrayBuilder assignStatements) - { - // Don't want to add a null check for something of the form `int?`. The type was - // already declared as nullable to indicate that null is ok. Adding a null check - // just disallows something that should be allowed. - var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable(); - - if (shouldAddNullCheck && preferThrowExpression && factory.SupportsThrowExpression()) - { - // Generate: this.x = x ?? throw ... - assignStatements.Add(CreateAssignWithNullCheckStatement( - factory, semanticModel.Compilation, parameter, fieldAccess)); - } - else - { - if (shouldAddNullCheck) - { - // generate: if (x == null) throw ... - nullCheckStatements.Add( - factory.CreateNullCheckAndThrowStatement(semanticModel, parameter)); - } - - // generate: this.x = x; - assignStatements.Add( - factory.ExpressionStatement( - factory.AssignmentStatement( - fieldAccess, - factory.IdentifierName(parameter.Name)))); - } - } - - public static SyntaxNode CreateAssignWithNullCheckStatement( - this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter, SyntaxNode fieldAccess) - { - return factory.ExpressionStatement(factory.AssignmentStatement( - fieldAccess, - factory.CoalesceExpression( - factory.IdentifierName(parameter.Name), - factory.CreateThrowArgumentNullExpression(compilation, parameter)))); - } - public static async Task OverridePropertyAsync( this SyntaxGenerator codeFactory, IPropertySymbol overriddenProperty, diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems index 1969c93209650..824a4a4616610 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems @@ -256,6 +256,14 @@ + + + + + + + + @@ -484,6 +492,7 @@ + @@ -508,6 +517,7 @@ + diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/ITypeGenerator.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeGenerator.cs similarity index 100% rename from src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/ITypeGenerator.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeGenerator.cs diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeParameterSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeParameterSymbolExtensions.cs similarity index 100% rename from src/Workspaces/Core/Portable/Shared/Extensions/ITypeParameterSymbolExtensions.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeParameterSymbolExtensions.cs diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs similarity index 100% rename from src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.AnonymousTypeRemover.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs similarity index 100% rename from src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.CompilationTypeGenerator.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.CompilationTypeGenerator.cs similarity index 100% rename from src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.CompilationTypeGenerator.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.CompilationTypeGenerator.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.SubstituteTypesVisitor.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.SubstituteTypesVisitor.cs similarity index 100% rename from src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.SubstituteTypesVisitor.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.SubstituteTypesVisitor.cs diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs similarity index 100% rename from src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs similarity index 100% rename from src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs index 47fea31801a29..452f208687b25 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs @@ -762,4 +762,75 @@ public static bool IsReadOnlySpan([NotNullWhen(true)] this ITypeSymbol? type) public static bool IsInlineArray([NotNullWhen(true)] this ITypeSymbol? type) => type is INamedTypeSymbol namedType && namedType.OriginalDefinition.GetAttributes().Any(static a => a.AttributeClass?.SpecialType == SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute); + + [return: NotNullIfNotNull(parameterName: nameof(type))] + public static ITypeSymbol? RemoveUnavailableTypeParameters( + this ITypeSymbol? type, + Compilation compilation, + IEnumerable availableTypeParameters) + { + return type?.RemoveUnavailableTypeParameters(compilation, availableTypeParameters.Select(t => t.Name).ToSet()); + } + + [return: NotNullIfNotNull(parameterName: nameof(type))] + private static ITypeSymbol? RemoveUnavailableTypeParameters( + this ITypeSymbol? type, + Compilation compilation, + ISet availableTypeParameterNames) + { + return type?.Accept(new UnavailableTypeParameterRemover(compilation, availableTypeParameterNames)); + } + + [return: NotNullIfNotNull(parameterName: nameof(type))] + public static ITypeSymbol? RemoveAnonymousTypes( + this ITypeSymbol? type, + Compilation compilation) + { + return type?.Accept(new AnonymousTypeRemover(compilation)); + } + + [return: NotNullIfNotNull(parameterName: nameof(type))] + public static ITypeSymbol? RemoveUnnamedErrorTypes( + this ITypeSymbol? type, + Compilation compilation) + { + return type?.Accept(new UnnamedErrorTypeRemover(compilation)); + } + public static IList GetReferencedMethodTypeParameters( + this ITypeSymbol? type, IList? result = null) + { + result ??= []; + type?.Accept(new CollectTypeParameterSymbolsVisitor(result, onlyMethodTypeParameters: true)); + return result; + } + + public static IList GetReferencedTypeParameters( + this ITypeSymbol? type, IList? result = null) + { + result ??= []; + type?.Accept(new CollectTypeParameterSymbolsVisitor(result, onlyMethodTypeParameters: false)); + return result; + } + + [return: NotNullIfNotNull(parameterName: nameof(type))] + public static ITypeSymbol? SubstituteTypes( + this ITypeSymbol? type, + IDictionary mapping, + Compilation compilation) + where TType1 : ITypeSymbol + where TType2 : ITypeSymbol + { + return type.SubstituteTypes(mapping, new CompilationTypeGenerator(compilation)); + } + + [return: NotNullIfNotNull(parameterName: nameof(type))] + public static ITypeSymbol? SubstituteTypes( + this ITypeSymbol? type, + IDictionary mapping, + ITypeGenerator typeGenerator) + where TType1 : ITypeSymbol + where TType2 : ITypeSymbol + { + return type?.Accept(new SubstituteTypesVisitor(mapping, typeGenerator)); + } } diff --git a/src/Workspaces/Core/Portable/Shared/Utilities/EnumValueUtilities.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/EnumValueUtilities.cs similarity index 100% rename from src/Workspaces/Core/Portable/Shared/Utilities/EnumValueUtilities.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/EnumValueUtilities.cs diff --git a/src/Workspaces/Core/Portable/Utilities/ParameterName.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ParameterName.cs similarity index 100% rename from src/Workspaces/Core/Portable/Utilities/ParameterName.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/ParameterName.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CSharpWorkspaceExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CSharpWorkspaceExtensions.projitems index 9c4e4383030e3..9ae36e4cfee9e 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CSharpWorkspaceExtensions.projitems +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/CSharpWorkspaceExtensions.projitems @@ -55,6 +55,7 @@ + diff --git a/src/Workspaces/CSharp/Portable/Extensions/SemanticModelExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/SemanticModelExtensions.cs similarity index 100% rename from src/Workspaces/CSharp/Portable/Extensions/SemanticModelExtensions.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/SemanticModelExtensions.cs diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs index 1ae9968af3955..3d1893fcdf224 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs @@ -39,6 +39,12 @@ public override SyntaxTrivia CarriageReturnLineFeed public override SyntaxTrivia ElasticCarriageReturnLineFeed => SyntaxFactory.ElasticCarriageReturnLineFeed; + public override bool SupportsThrowExpression() + => true; + + public override bool RequiresExplicitImplementationForInterfaceMembers + => false; + public override SyntaxTrivia EndOfLine(string text) => SyntaxFactory.EndOfLine(text); diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerator.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerator.cs index 8274ff6f918c9..ff18482a5f37d 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerator.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/CodeGenerator.cs @@ -20,75 +20,79 @@ internal static class CodeGenerator /// public static readonly SyntaxAnnotation Annotation = new(nameof(CodeGenerator)); - private static ICodeGenerationService GetCodeGenerationService(SolutionServices services, string language) + private static ICodeGenerationService GetCodeGenerationService(HostWorkspaceServices services, string language) +#if CODE_STYLE + => services.GetExtendedLanguageServices(language).GetRequiredService(); +#else => services.GetLanguageServices(language).GetRequiredService(); +#endif /// /// Create a new solution where the declaration of the destination symbol has an additional event of the same signature as the specified event symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddEventDeclarationAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, IEventSymbol @event, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddEventAsync(context, destination, @event, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddEventAsync(context, destination, @event, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional field of the same signature as the specified field symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddFieldDeclarationAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, IFieldSymbol field, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddFieldAsync(context, destination, field, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddFieldAsync(context, destination, field, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional method of the same signature as the specified method symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddMethodDeclarationAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, IMethodSymbol method, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddMethodAsync(context, destination, method, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddMethodAsync(context, destination, method, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional property of the same signature as the specified property symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddPropertyDeclarationAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, IPropertySymbol property, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddPropertyAsync(context, destination, property, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddPropertyAsync(context, destination, property, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional named type of the same signature as the specified named type symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddNamedTypeDeclarationAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, INamedTypeSymbol namedType, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddNamedTypeAsync(context, destination, namedType, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddNamedTypeAsync(context, destination, namedType, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional named type of the same signature as the specified named type symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddNamedTypeDeclarationAsync(CodeGenerationSolutionContext context, INamespaceSymbol destination, INamedTypeSymbol namedType, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddNamedTypeAsync(context, destination, namedType, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddNamedTypeAsync(context, destination, namedType, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional namespace of the same signature as the specified namespace symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddNamespaceDeclarationAsync(CodeGenerationSolutionContext context, INamespaceSymbol destination, INamespaceSymbol @namespace, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddNamespaceAsync(context, destination, @namespace, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddNamespaceAsync(context, destination, @namespace, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has an additional namespace or type of the same signature as the specified namespace or type symbol. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddNamespaceOrTypeDeclarationAsync(CodeGenerationSolutionContext context, INamespaceSymbol destination, INamespaceOrTypeSymbol namespaceOrType, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddNamespaceOrTypeAsync(context, destination, namespaceOrType, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddNamespaceOrTypeAsync(context, destination, namespaceOrType, cancellationToken); /// /// Create a new solution where the declaration of the destination symbol has additional members of the same signature as the specified member symbols. /// Returns the document in the new solution where the destination symbol is declared. /// public static Task AddMemberDeclarationsAsync(CodeGenerationSolutionContext context, INamedTypeSymbol destination, IEnumerable members, CancellationToken cancellationToken) - => GetCodeGenerationService(context.Solution.Services, destination.Language).AddMembersAsync(context, destination, members, cancellationToken); + => GetCodeGenerationService(context.Solution.Workspace.Services, destination.Language).AddMembersAsync(context, destination, members, cancellationToken); /// /// Returns true if additional declarations can be added to the destination symbol's declaration. /// public static bool CanAdd(Solution solution, ISymbol destination, CancellationToken cancellationToken) - => GetCodeGenerationService(solution.Services, destination.Language).CanAddTo(destination, solution, cancellationToken); + => GetCodeGenerationService(solution.Workspace.Services, destination.Language).CanAddTo(destination, solution, cancellationToken); } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/IPropertySymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/IPropertySymbolExtensions.cs index 581b1de1dd6c6..2b2a1a8d5c1f3 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/IPropertySymbolExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/IPropertySymbolExtensions.cs @@ -70,4 +70,10 @@ static bool ShouldRemoveAttribute(AttributeData a, (INamedTypeSymbol[] attribute => arg.attributesToRemove.Any(attr => attr.Equals(a.AttributeClass)) || a.AttributeClass?.IsAccessibleWithin(arg.accessibleWithin) == false; } + + public static bool IsWritableInConstructor(this IPropertySymbol property) + => property.SetMethod != null || ContainsBackingField(property); + + private static bool ContainsBackingField(IPropertySymbol property) + => property.GetBackingFieldIfAny() != null; } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.cs deleted file mode 100644 index fd0642d85e4d1..0000000000000 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/ITypeSymbolExtensions.cs +++ /dev/null @@ -1,49 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for more information. - -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; - -namespace Microsoft.CodeAnalysis.Shared.Extensions; - -internal static partial class ITypeSymbolExtensions -{ - public static IList GetReferencedMethodTypeParameters( - this ITypeSymbol? type, IList? result = null) - { - result ??= []; - type?.Accept(new CollectTypeParameterSymbolsVisitor(result, onlyMethodTypeParameters: true)); - return result; - } - - public static IList GetReferencedTypeParameters( - this ITypeSymbol? type, IList? result = null) - { - result ??= []; - type?.Accept(new CollectTypeParameterSymbolsVisitor(result, onlyMethodTypeParameters: false)); - return result; - } - - [return: NotNullIfNotNull(parameterName: nameof(type))] - public static ITypeSymbol? SubstituteTypes( - this ITypeSymbol? type, - IDictionary mapping, - Compilation compilation) - where TType1 : ITypeSymbol - where TType2 : ITypeSymbol - { - return type.SubstituteTypes(mapping, new CompilationTypeGenerator(compilation)); - } - - [return: NotNullIfNotNull(parameterName: nameof(type))] - public static ITypeSymbol? SubstituteTypes( - this ITypeSymbol? type, - IDictionary mapping, - ITypeGenerator typeGenerator) - where TType1 : ITypeSymbol - where TType2 : ITypeSymbol - { - return type?.Accept(new SubstituteTypesVisitor(mapping, typeGenerator)); - } -} diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions.cs index 14b498d91e046..e1dd24c448120 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions.cs @@ -5,10 +5,19 @@ using System; using System.Collections.Generic; using System.Collections.Immutable; +using System.Diagnostics.CodeAnalysis; +using Microsoft.CodeAnalysis.CodeGeneration; using Microsoft.CodeAnalysis.Editing; +using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Simplification; using Roslyn.Utilities; +#if CODE_STYLE +using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers; +#else +using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers; +#endif + namespace Microsoft.CodeAnalysis.Shared.Extensions; internal static partial class SyntaxGeneratorExtensions @@ -230,4 +239,215 @@ public static ImmutableArray GetSetAccessorStatements( ? default : generator.CreateThrowNotImplementedStatementBlock(compilation); } + + private static bool TryGetValue(IDictionary? dictionary, string key, [NotNullWhen(true)] out string? value) + { + value = null; + return + dictionary != null && + dictionary.TryGetValue(key, out value); + } + + private static bool TryGetValue(IDictionary? dictionary, string key, [NotNullWhen(true)] out string? value) + { + value = null; + if (dictionary != null && dictionary.TryGetValue(key, out var symbol)) + { + value = symbol.Name; + return true; + } + + return false; + } + + public static ImmutableArray CreateFieldsForParameters( + ImmutableArray parameters, ImmutableDictionary? parameterToNewFieldMap, bool isContainedInUnsafeType) + { + using var _ = ArrayBuilder.GetInstance(out var result); + foreach (var parameter in parameters) + { + // For non-out parameters, create a field and assign the parameter to it. + if (parameter.RefKind != RefKind.Out && + TryGetValue(parameterToNewFieldMap, parameter.Name, out var fieldName)) + { + result.Add(CodeGenerationSymbolFactory.CreateFieldSymbol( + attributes: default, + accessibility: Accessibility.Private, + modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameter.RequiresUnsafeModifier()), + type: parameter.Type, + name: fieldName)); + } + } + + return result.ToImmutableAndClear(); + } + + public static ImmutableArray CreatePropertiesForParameters( + ImmutableArray parameters, ImmutableDictionary? parameterToNewPropertyMap, bool isContainedInUnsafeType) + { + using var _ = ArrayBuilder.GetInstance(out var result); + foreach (var parameter in parameters) + { + // For non-out parameters, create a property and assign the parameter to it. + if (parameter.RefKind != RefKind.Out && + TryGetValue(parameterToNewPropertyMap, parameter.Name, out var propertyName)) + { + result.Add(CodeGenerationSymbolFactory.CreatePropertySymbol( + attributes: default, + accessibility: Accessibility.Public, + modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameter.RequiresUnsafeModifier()), + type: parameter.Type, + refKind: RefKind.None, + explicitInterfaceImplementations: [], + name: propertyName, + parameters: [], + getMethod: CodeGenerationSymbolFactory.CreateAccessorSymbol( + attributes: default, + accessibility: default, + statements: default), + setMethod: null)); + } + } + + return result.ToImmutableAndClear(); + } + + public static ImmutableArray CreateAssignmentStatements( + this SyntaxGenerator factory, + SyntaxGeneratorInternal generatorInternal, + SemanticModel semanticModel, + ImmutableArray parameters, + IDictionary? parameterToExistingFieldMap, + IDictionary? parameterToNewFieldMap, + bool addNullChecks, + bool preferThrowExpression) + { + var nullCheckStatements = ArrayBuilder.GetInstance(); + var assignStatements = ArrayBuilder.GetInstance(); + + foreach (var parameter in parameters) + { + var refKind = parameter.RefKind; + var parameterType = parameter.Type; + var parameterName = parameter.Name; + + if (refKind == RefKind.Out) + { + // If it's an out param, then don't create a field for it. Instead, assign + // the default value for that type (i.e. "default(...)") to it. + var assignExpression = factory.AssignmentStatement( + factory.IdentifierName(parameterName), + factory.DefaultExpression(parameterType)); + var statement = factory.ExpressionStatement(assignExpression); + assignStatements.Add(statement); + } + else + { + // For non-out parameters, create a field and assign the parameter to it. + // TODO: I'm not sure that's what we really want for ref parameters. + if (TryGetValue(parameterToExistingFieldMap, parameterName, out var fieldName) || + TryGetValue(parameterToNewFieldMap, parameterName, out fieldName)) + { + var fieldAccess = factory.MemberAccessExpression(factory.ThisExpression(), factory.IdentifierName(fieldName)) + .WithAdditionalAnnotations(Simplifier.Annotation); + + factory.AddAssignmentStatements( + generatorInternal, + semanticModel, parameter, fieldAccess, + addNullChecks, preferThrowExpression, + nullCheckStatements, assignStatements); + } + } + } + + return nullCheckStatements.ToImmutableAndFree().Concat(assignStatements.ToImmutableAndFree()); + } + + public static void AddAssignmentStatements( + this SyntaxGenerator factory, + SyntaxGeneratorInternal generatorInternal, + SemanticModel semanticModel, + IParameterSymbol parameter, + SyntaxNode fieldAccess, + bool addNullChecks, + bool preferThrowExpression, + ArrayBuilder nullCheckStatements, + ArrayBuilder assignStatements) + { + // Don't want to add a null check for something of the form `int?`. The type was + // already declared as nullable to indicate that null is ok. Adding a null check + // just disallows something that should be allowed. + var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable(); + + if (shouldAddNullCheck && preferThrowExpression && generatorInternal.SupportsThrowExpression()) + { + // Generate: this.x = x ?? throw ... + assignStatements.Add(CreateAssignWithNullCheckStatement( + factory, semanticModel.Compilation, parameter, fieldAccess)); + } + else + { + if (shouldAddNullCheck) + { + // generate: if (x == null) throw ... + nullCheckStatements.Add( + factory.CreateNullCheckAndThrowStatement(generatorInternal, semanticModel, parameter)); + } + + // generate: this.x = x; + assignStatements.Add( + factory.ExpressionStatement( + factory.AssignmentStatement( + fieldAccess, + factory.IdentifierName(parameter.Name)))); + } + } + + public static SyntaxNode CreateAssignWithNullCheckStatement( + this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter, SyntaxNode fieldAccess) + { + return factory.ExpressionStatement(factory.AssignmentStatement( + fieldAccess, + factory.CoalesceExpression( + factory.IdentifierName(parameter.Name), + factory.CreateThrowArgumentNullExpression(compilation, parameter)))); + } + + public static SyntaxNode CreateThrowArgumentNullExpression(this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) + => factory.ThrowExpression(CreateNewArgumentNullException(factory, compilation, parameter)); + + private static SyntaxNode CreateNewArgumentNullException(SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) + { + var type = compilation.GetTypeByMetadataName(typeof(ArgumentNullException).FullName!); + Contract.ThrowIfNull(type); + return factory.ObjectCreationExpression(type, + factory.NameOfExpression( + factory.IdentifierName(parameter.Name))).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation); + } + + public static SyntaxNode CreateNullCheckAndThrowStatement( + this SyntaxGenerator factory, + SyntaxGeneratorInternal generatorInternal, + SemanticModel semanticModel, + IParameterSymbol parameter) + { + var condition = factory.CreateNullCheckExpression(generatorInternal, semanticModel, parameter.Name); + var throwStatement = factory.CreateThrowArgumentNullExceptionStatement(semanticModel.Compilation, parameter); + + // generates: if (s is null) { throw new ArgumentNullException(nameof(s)); } + return factory.IfStatement(condition, [throwStatement]); + } + public static SyntaxNode CreateNullCheckExpression( + this SyntaxGenerator factory, SyntaxGeneratorInternal generatorInternal, SemanticModel semanticModel, string identifierName) + { + var identifier = factory.IdentifierName(identifierName); + var nullExpr = factory.NullLiteralExpression(); + var condition = generatorInternal.SupportsPatterns(semanticModel.SyntaxTree.Options) + ? generatorInternal.IsPatternExpression(identifier, generatorInternal.ConstantPattern(nullExpr)) + : factory.ReferenceEqualsExpression(identifier, nullExpr); + return condition; + } + + public static SyntaxNode CreateThrowArgumentNullExceptionStatement(this SyntaxGenerator factory, Compilation compilation, IParameterSymbol parameter) + => factory.ThrowStatement(CreateNewArgumentNullException(factory, compilation, parameter)); } diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs similarity index 80% rename from src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs rename to src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs index 6ebbbe5063f0c..3919fc0d6a83b 100644 --- a/src/Workspaces/Core/Portable/Shared/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/SyntaxGeneratorExtensions_CreateEqualsMethod.cs @@ -5,6 +5,7 @@ #nullable disable using System; +using System.Collections.Generic; using System.Collections.Immutable; using System.Diagnostics.CodeAnalysis; using System.Linq; @@ -14,9 +15,16 @@ using Microsoft.CodeAnalysis.PooledObjects; using Microsoft.CodeAnalysis.Shared.Collections; using Microsoft.CodeAnalysis.Shared.Utilities; +using Microsoft.CodeAnalysis.Simplification; using Microsoft.CodeAnalysis.Text; using Roslyn.Utilities; +#if CODE_STYLE +using DeclarationModifiers = Microsoft.CodeAnalysis.Internal.Editing.DeclarationModifiers; +#else +using DeclarationModifiers = Microsoft.CodeAnalysis.Editing.DeclarationModifiers; +#endif + namespace Microsoft.CodeAnalysis.Shared.Extensions; internal static partial class SyntaxGeneratorExtensions @@ -79,7 +87,7 @@ public static IMethodSymbol CreateIEquatableEqualsMethod( type: constructedEquatableType.GetTypeArguments()[0], attributes: ImmutableArray.Empty)); - if (factory.RequiresExplicitImplementationForInterfaceMembers) + if (generatorInternal.RequiresExplicitImplementationForInterfaceMembers) { return CodeGenerationSymbolFactory.CreateMethodSymbol( methodSymbol, @@ -132,12 +140,12 @@ private static ImmutableArray CreateEqualsMethodStatements( // return statement of 'Equals'. using var _2 = ArrayBuilder.GetInstance(out var expressions); - if (factory.SyntaxGeneratorInternal.SupportsPatterns(parseOptions)) + if (generatorInternal.SupportsPatterns(parseOptions)) { // If we support patterns then we can do "return obj is MyType myType && ..." expressions.Add( - factory.SyntaxGeneratorInternal.IsPatternExpression(objNameExpression, - factory.SyntaxGeneratorInternal.DeclarationPattern(containingType, localName))); + generatorInternal.IsPatternExpression(objNameExpression, + generatorInternal.DeclarationPattern(containingType, localName))); } else if (containingType.IsValueType) { @@ -159,7 +167,7 @@ private static ImmutableArray CreateEqualsMethodStatements( // // var myType = (MyType)obj; - var localDeclaration = factory.SimpleLocalDeclarationStatement(factory.SyntaxGeneratorInternal, + var localDeclaration = factory.SimpleLocalDeclarationStatement(generatorInternal, containingType, localName, factory.CastExpression(containingType, objNameExpression)); statements.Add(ifStatement); @@ -171,13 +179,14 @@ private static ImmutableArray CreateEqualsMethodStatements( // // var myType = obj as MyType; - var localDeclaration = factory.SimpleLocalDeclarationStatement(factory.SyntaxGeneratorInternal, + var localDeclaration = factory.SimpleLocalDeclarationStatement(generatorInternal, containingType, localName, factory.TryCastExpression(objNameExpression, containingType)); statements.Add(localDeclaration); // Ensure that the parameter we got was not null (which also ensures the 'as' test succeeded): - AddReferenceNotNullCheck(factory, compilation, parseOptions, localNameExpression, expressions); + AddReferenceNotNullCheck( + factory, generatorInternal, compilation, parseOptions, localNameExpression, expressions); } if (!containingType.IsValueType && HasExistingBaseEqualsMethod(containingType)) @@ -280,7 +289,8 @@ private static ImmutableArray CreateIEquatableEqualsMethodStatements // It's not a value type. Ensure that the parameter we got was not null. // if we support patterns, we can do `x is not null` - AddReferenceNotNullCheck(factory, compilation, parseOptions, otherNameExpression, expressions); + AddReferenceNotNullCheck( + factory, generatorInternal, compilation, parseOptions, otherNameExpression, expressions); if (HasExistingBaseEqualsMethod(containingType)) { @@ -310,7 +320,7 @@ private static ImmutableArray CreateIEquatableEqualsMethodStatements } private static void AddReferenceNotNullCheck( - SyntaxGenerator factory, Compilation compilation, ParseOptions parseOptions, SyntaxNode otherNameExpression, ArrayBuilder expressions) + SyntaxGenerator factory, SyntaxGeneratorInternal generatorInternal, Compilation compilation, ParseOptions parseOptions, SyntaxNode otherNameExpression, ArrayBuilder expressions) { var nullLiteral = factory.NullLiteralExpression(); if (compilation.Language == LanguageNames.VisualBasic) @@ -320,22 +330,21 @@ private static void AddReferenceNotNullCheck( return; } - var generator = factory.SyntaxGeneratorInternal; - if (generator.SyntaxFacts.SupportsNotPattern(parseOptions)) + if (generatorInternal.SyntaxFacts.SupportsNotPattern(parseOptions)) { // If we support not patterns then we can do "obj is not null && ..." expressions.Add( - generator.IsPatternExpression(otherNameExpression, - generator.NotPattern( - generator.ConstantPattern(nullLiteral)))); + generatorInternal.IsPatternExpression(otherNameExpression, + generatorInternal.NotPattern( + generatorInternal.ConstantPattern(nullLiteral)))); } - else if (generator.SupportsPatterns(parseOptions)) + else if (generatorInternal.SupportsPatterns(parseOptions)) { // if we support patterns then we can do `!(obj is null)` expressions.Add( factory.LogicalNotExpression( - generator.IsPatternExpression(otherNameExpression, - generator.ConstantPattern(nullLiteral)))); + generatorInternal.IsPatternExpression(otherNameExpression, + generatorInternal.ConstantPattern(nullLiteral)))); } else { @@ -443,4 +452,64 @@ where method.IsOverride && return existingMethods.Any(); } + + public static ImmutableArray CreateMemberDelegatingConstructor( + this SyntaxGenerator factory, + SyntaxGeneratorInternal generatorInternal, + SemanticModel semanticModel, + string typeName, + INamedTypeSymbol? containingType, + ImmutableArray parameters, + Accessibility accessibility, + ImmutableDictionary? parameterToExistingMemberMap, + ImmutableDictionary? parameterToNewMemberMap, + bool addNullChecks, + bool preferThrowExpression, + bool generateProperties, + bool isContainedInUnsafeType) + { + var newMembers = generateProperties + ? CreatePropertiesForParameters(parameters, parameterToNewMemberMap, isContainedInUnsafeType) + : CreateFieldsForParameters(parameters, parameterToNewMemberMap, isContainedInUnsafeType); + var statements = factory.CreateAssignmentStatements( + generatorInternal, semanticModel, + parameters, parameterToExistingMemberMap, parameterToNewMemberMap, + addNullChecks, preferThrowExpression).SelectAsArray( + s => s.WithAdditionalAnnotations(Simplifier.Annotation)); + + var constructor = CodeGenerationSymbolFactory.CreateConstructorSymbol( + attributes: default, + accessibility: accessibility, + modifiers: new DeclarationModifiers(isUnsafe: !isContainedInUnsafeType && parameters.Any(static p => p.RequiresUnsafeModifier())), + typeName: typeName, + parameters: parameters, + statements: statements, + thisConstructorArguments: ShouldGenerateThisConstructorCall(containingType, parameterToExistingMemberMap) + ? [] + : default); + + return newMembers.Concat(constructor); + } + + private static bool ShouldGenerateThisConstructorCall( + INamedTypeSymbol? containingType, + IDictionary? parameterToExistingFieldMap) + { + if (containingType?.TypeKind == TypeKind.Struct) + { + // Special case. If we're generating a struct constructor, then we'll need + // to initialize all fields in the struct, not just the ones we're creating. + // If there is any field or auto-property not being set by a parameter, we + // call the default constructor. + + return containingType.GetMembers() + .OfType() + .Where(field => !field.IsStatic) + .Select(field => field.AssociatedSymbol ?? field) + .Except(parameterToExistingFieldMap?.Values ?? []) + .Any(); + } + + return false; + } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs index 5e629108ccba9..b87a79832bdf4 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs @@ -26,6 +26,10 @@ internal abstract class SyntaxGeneratorInternal : ILanguageService public abstract SyntaxTrivia EndOfLine(string text); public abstract SyntaxTrivia SingleLineComment(string text); + public abstract bool RequiresExplicitImplementationForInterfaceMembers { get; } + + public abstract bool SupportsThrowExpression(); + /// /// Creates a statement that declares a single local variable with an optional initializer. /// diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems index b522e8be46a20..3aa2b46b92d4e 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/WorkspaceExtensions.projitems @@ -18,8 +18,7 @@ - - + @@ -40,7 +39,6 @@ - @@ -84,8 +82,6 @@ - - diff --git a/src/Workspaces/VisualBasic/Portable/Extensions/SemanticModelExtensions.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SemanticModelExtensions.vb similarity index 100% rename from src/Workspaces/VisualBasic/Portable/Extensions/SemanticModelExtensions.vb rename to src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/Extensions/SemanticModelExtensions.vb diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb index ea088045ecfea..c8d1a1c29926e 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb @@ -40,6 +40,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Public Overrides ReadOnly Property ElasticCarriageReturnLineFeed As SyntaxTrivia = SyntaxFactory.ElasticCarriageReturnLineFeed + Public Overrides Function SupportsThrowExpression() As Boolean + Return False + End Function + + Public Overrides ReadOnly Property RequiresExplicitImplementationForInterfaceMembers As Boolean = True + Public Overrides Function EndOfLine(text As String) As SyntaxTrivia Return SyntaxFactory.EndOfLine(text) End Function diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/VisualBasicWorkspaceExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/VisualBasicWorkspaceExtensions.projitems index 91d7087582872..d886374b01356 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/VisualBasicWorkspaceExtensions.projitems +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/VisualBasicWorkspaceExtensions.projitems @@ -55,6 +55,7 @@ + diff --git a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb index 47ca86f1e7a52..0631af24ca037 100644 --- a/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb +++ b/src/Workspaces/VisualBasic/Portable/CodeGeneration/VisualBasicSyntaxGenerator.vb @@ -27,8 +27,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Friend Overrides ReadOnly Property ElasticMarker As SyntaxTrivia = SyntaxFactory.ElasticMarker - Friend Overrides ReadOnly Property RequiresExplicitImplementationForInterfaceMembers As Boolean = True - Friend Overrides ReadOnly Property SyntaxGeneratorInternal As SyntaxGeneratorInternal = VisualBasicSyntaxGeneratorInternal.Instance Friend Overrides Function Whitespace(text As String) As SyntaxTrivia @@ -381,10 +379,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration Throw New NotSupportedException("ThrowExpressions are not supported in Visual Basic") End Function - Friend Overrides Function SupportsThrowExpression() As Boolean - Return False - End Function - Public Overrides Function NameExpression(namespaceOrTypeSymbol As INamespaceOrTypeSymbol) As SyntaxNode Return namespaceOrTypeSymbol.GenerateTypeSyntax() End Function diff --git a/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj b/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj index 94e93344d4e42..bf7382ccb4c56 100644 --- a/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj +++ b/src/Workspaces/VisualBasic/Portable/Microsoft.CodeAnalysis.VisualBasic.Workspaces.vbproj @@ -53,6 +53,9 @@ + + + \ No newline at end of file