Merge main to main-vs-deps

src/Analyzers/CSharp/CodeFixes/UseCompoundAssignment/CSharpUseCompoundAssignmentCodeFixProvider.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.UseCompoundAssignment;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseCompoundAssignment
@@ -30,14 +31,32 @@ protected override AssignmentExpressionSyntax Assignment(
             return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right);
         }
 
-        protected override ExpressionSyntax Increment(ExpressionSyntax left)
-        {
-            return SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, left);
-        }
+        protected override ExpressionSyntax Increment(ExpressionSyntax left, bool postfix)
+            => postfix
+                ? Postfix(SyntaxKind.PostIncrementExpression, left)
+                : Prefix(SyntaxKind.PreIncrementExpression, left);
+
+        protected override ExpressionSyntax Decrement(ExpressionSyntax left, bool postfix)
+            => postfix
+                ? Postfix(SyntaxKind.PostDecrementExpression, left)
+                : Prefix(SyntaxKind.PreDecrementExpression, left);
 
-        protected override ExpressionSyntax Decrement(ExpressionSyntax left)
+        private static ExpressionSyntax Postfix(SyntaxKind kind, ExpressionSyntax operand)
+            => SyntaxFactory.PostfixUnaryExpression(kind, operand);
+
+        private static ExpressionSyntax Prefix(SyntaxKind kind, ExpressionSyntax operand)
+            => SyntaxFactory.PrefixUnaryExpression(kind, operand);
+
+        protected override bool PreferPostfix(ISyntaxFactsService syntaxFacts, AssignmentExpressionSyntax currentAssignment)
         {
-            return SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostDecrementExpression, left);
+            // in `for (...; x = x + 1)` we prefer to translate that idiomatically as `for (...; x++)`
+            if (currentAssignment.Parent is ForStatementSyntax forStatement &&
+                forStatement.Incrementors.Contains(currentAssignment))
+            {
+                return true;
+            }
+
+            return base.PreferPostfix(syntaxFacts, currentAssignment);
         }
     }
 }

src/Analyzers/CSharp/Tests/UseCompoundAssignment/UseCompoundAssignmentTests.cs

@@ -1093,5 +1093,109 @@ void M()
     }
 }");
         }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        public async Task TestIncrementInExpressionContext()
+        {
+            await TestInRegularAndScript1Async(
+@"public class C
+{
+    void M(int i)
+    {
+        M(i [||]= i + 1);
+    }
+}",
+@"public class C
+{
+    void M(int i)
+    {
+        M(++i);
+    }
+}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData("switch($$) { }")]
+        [InlineData("while(($$) > 0) { }")]
+        [InlineData("_ = true ? $$ : 0;")]
+        [InlineData("_ = ($$);")]
+        public async Task TestPrefixIncrement1(string expressionContext)
+        {
+            var before = expressionContext.Replace("$$", "i [||]= i + 1");
+            var after = expressionContext.Replace("$$", "++i");
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    void M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    void M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData("return $$;")]
+        [InlineData("return true ? $$ : 0;")]
+        [InlineData("return ($$);")]
+        public async Task TestPrefixIncrement2(string expressionContext)
+        {
+            var before = expressionContext.Replace("$$", "i [||]= i + 1");
+            var after = expressionContext.Replace("$$", "++i");
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
+
+        [WorkItem(38054, "https://github.com/dotnet/roslyn/issues/53969")]
+        [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUseCompoundAssignment)]
+        [InlineData(
+            "/* Before */ i [||]= i + 1; /* After */",
+            "/* Before */ i++; /* After */")]
+        [InlineData(
+            "M( /* Before */ i [||]= i + 1 /* After */ );",
+            "M( /* Before */ ++i /* After */ );")]
+        [InlineData(
+            "M( /* Before */ i [||]= i - 1 /* After */ );",
+            "M( /* Before */ --i /* After */ );")]
+        public async Task TestTriviaPreserved(string before, string after)
+        {
+            await TestInRegularAndScript1Async(
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {before}
+    }}
+}}",
+@$"public class C
+{{
+    int M(int i)
+    {{
+        {after}
+    }}
+}}");
+        }
     }
 }

src/Analyzers/Core/CodeFixes/UseCompoundAssignment/AbstractUseCompoundAssignmentCodeFixProvider.cs

@@ -41,8 +41,8 @@ protected AbstractUseCompoundAssignmentCodeFixProvider(
         protected abstract SyntaxToken Token(TSyntaxKind kind);
         protected abstract TAssignmentSyntax Assignment(
             TSyntaxKind assignmentOpKind, TExpressionSyntax left, SyntaxToken syntaxToken, TExpressionSyntax right);
-        protected abstract TExpressionSyntax Increment(TExpressionSyntax left);
-        protected abstract TExpressionSyntax Decrement(TExpressionSyntax left);
+        protected abstract TExpressionSyntax Increment(TExpressionSyntax left, bool postfix);
+        protected abstract TExpressionSyntax Decrement(TExpressionSyntax left, bool postfix);
 
         public override Task RegisterCodeFixesAsync(CodeFixContext context)
         {
@@ -68,8 +68,11 @@ protected override Task FixAllAsync(
                 var assignment = diagnostic.AdditionalLocations[0].FindNode(getInnermostNodeForTie: true, cancellationToken);
 
                 editor.ReplaceNode(assignment,
-                    (currentAssignment, generator) =>
+                    (current, generator) =>
                     {
+                        if (current is not TAssignmentSyntax currentAssignment)
+                            return current;
+
                         syntaxFacts.GetPartsOfAssignmentExpressionOrStatement(currentAssignment,
                             out var leftOfAssign, out var equalsToken, out var rightOfAssign);
 
@@ -80,14 +83,10 @@ protected override Task FixAllAsync(
                             out _, out var opToken, out var rightExpr);
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Increment))
-                        {
-                            return Increment((TExpressionSyntax)leftOfAssign);
-                        }
+                            return Increment((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment);
 
                         if (diagnostic.Properties.ContainsKey(UseCompoundAssignmentUtilities.Decrement))
-                        {
-                            return Decrement((TExpressionSyntax)leftOfAssign);
-                        }
+                            return Decrement((TExpressionSyntax)leftOfAssign, PreferPostfix(syntaxFacts, currentAssignment)).WithTriviaFrom(currentAssignment);
 
                         var assignmentOpKind = _binaryToAssignmentMap[syntaxKinds.Convert<TSyntaxKind>(rightOfAssign.RawKind)];
                         var compoundOperator = Token(_assignmentToTokenMap[assignmentOpKind]);
@@ -102,6 +101,17 @@ protected override Task FixAllAsync(
             return Task.CompletedTask;
         }
 
+        protected virtual bool PreferPostfix(ISyntaxFactsService syntaxFacts, TAssignmentSyntax currentAssignment)
+        {
+            // If we have `x = x + 1;` on it's own, then we prefer `x++` as idiomatic.
+            if (syntaxFacts.IsSimpleAssignmentStatement(currentAssignment.Parent))
+                return true;
+
+            // In any other circumstance, the value of the assignment might be read, so we need to transform to
+            // ++x to ensure that we preserve semantics.
+            return false;
+        }
+
         private class MyCodeAction : CustomCodeActions.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)

src/Analyzers/VisualBasic/CodeFixes/UseCompoundAssignment/VisualBasicUseCompoundAssignmentCodeFixProvider.vb

@@ -30,11 +30,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UseCompoundAssignment
             Return SyntaxFactory.AssignmentStatement(assignmentOpKind, left, syntaxToken, right)
         End Function
 
-        Protected Overrides Function Increment(left As ExpressionSyntax) As ExpressionSyntax
+        Protected Overrides Function Increment(left As ExpressionSyntax, postfix As Boolean) As ExpressionSyntax
             Throw ExceptionUtilities.Unreachable
         End Function
 
-        Protected Overrides Function Decrement(left As ExpressionSyntax) As ExpressionSyntax
+        Protected Overrides Function Decrement(left As ExpressionSyntax, postfix As Boolean) As ExpressionSyntax
             Throw ExceptionUtilities.Unreachable
         End Function
     End Class

src/Compilers/CSharp/Portable/SourceGeneration/CSharpGeneratorDriver.cs

@@ -46,7 +46,7 @@ public static CSharpGeneratorDriver Create(params ISourceGenerator[] generators)
         /// <param name="incrementalGenerators">The incremental generators to create this driver with</param>
         /// <returns>A new <see cref="CSharpGeneratorDriver"/> instance.</returns>
         public static CSharpGeneratorDriver Create(params IIncrementalGenerator[] incrementalGenerators)
-            => Create(incrementalGenerators.Select(WrapGenerator), additionalTexts: null);
+            => Create(incrementalGenerators.Select(GeneratorExtensions.AsSourceGenerator), additionalTexts: null);
 
         /// <summary>
         /// Creates a new instance of <see cref="CSharpGeneratorDriver"/> with the specified <see cref="ISourceGenerator"/>s and the provided options or default.

src/Compilers/Core/CodeAnalysisTest/Analyzers/AnalyzerFileReferenceTests.cs

@@ -253,7 +253,7 @@ public void TestLoadGenerators()
         {
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGeneratorsForAllLanguages();
-            var typeNames = generators.Select(g => GeneratorDriver.GetGeneratorType(g).FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
 
             AssertEx.SetEqual(new[]
             {
@@ -291,7 +291,7 @@ public void TestLoadCSharpGenerators()
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGenerators(LanguageNames.CSharp);
 
-            var typeNames = generators.Select(g => GeneratorDriver.GetGeneratorType(g).FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
             AssertEx.SetEqual(new[]
             {
                 "Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator",
@@ -313,7 +313,7 @@ public void TestLoadVisualBasicGenerators()
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
             var generators = reference.GetGenerators(LanguageNames.VisualBasic);
 
-            var typeNames = generators.Select(g => GeneratorDriver.GetGeneratorType(g).FullName);
+            var typeNames = generators.Select(g => g.GetGeneratorType().FullName);
             AssertEx.SetEqual(new[]
             {
                 "Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator",
@@ -436,7 +436,7 @@ public void TestLoadedGeneratorOrderIsDeterministic()
         {
             AnalyzerFileReference reference = CreateAnalyzerFileReference(Assembly.GetExecutingAssembly().Location);
 
-            var csharpGenerators = reference.GetGenerators(LanguageNames.CSharp).Select(g => GeneratorDriver.GetGeneratorType(g).FullName).ToArray();
+            var csharpGenerators = reference.GetGenerators(LanguageNames.CSharp).Select(g => g.GetGeneratorType().FullName).ToArray();
             Assert.Equal(10, csharpGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+SomeType+NestedGenerator", csharpGenerators[0]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator", csharpGenerators[1]);
@@ -449,7 +449,7 @@ public void TestLoadedGeneratorOrderIsDeterministic()
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestSourceAndIncrementalGenerator", csharpGenerators[8]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicAndCSharpGenerator", csharpGenerators[9]);
 
-            var vbGenerators = reference.GetGenerators(LanguageNames.VisualBasic).Select(g => GeneratorDriver.GetGeneratorType(g).FullName).ToArray();
+            var vbGenerators = reference.GetGenerators(LanguageNames.VisualBasic).Select(g => g.GetGeneratorType().FullName).ToArray();
             Assert.Equal(5, vbGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.CSharpAndVisualBasicGenerator", vbGenerators[0]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.TestIncrementalGenerator", vbGenerators[1]);
@@ -458,7 +458,7 @@ public void TestLoadedGeneratorOrderIsDeterministic()
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.VisualBasicOnlyGenerator", vbGenerators[4]);
 
             // generators load in language order (C#, F#, VB), and *do not* include duplicates
-            var allGenerators = reference.GetGeneratorsForAllLanguages().Select(g => GeneratorDriver.GetGeneratorType(g).FullName).ToArray();
+            var allGenerators = reference.GetGeneratorsForAllLanguages().Select(g => g.GetGeneratorType().FullName).ToArray();
             Assert.Equal(12, allGenerators.Length);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+SomeType+NestedGenerator", allGenerators[0]);
             Assert.Equal("Microsoft.CodeAnalysis.UnitTests.AnalyzerFileReferenceTests+TestGenerator", allGenerators[1]);

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -6,6 +6,7 @@ Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedMethods.get -> System.Co
 Microsoft.CodeAnalysis.Emit.EmitDifferenceResult.UpdatedTypes.get -> System.Collections.Immutable.ImmutableArray<System.Reflection.Metadata.TypeDefinitionHandle>
 Microsoft.CodeAnalysis.GeneratorAttribute.GeneratorAttribute(string! firstLanguage, params string![]! additionalLanguages) -> void
 Microsoft.CodeAnalysis.GeneratorAttribute.Languages.get -> string![]!
+Microsoft.CodeAnalysis.GeneratorExtensions
 Microsoft.CodeAnalysis.IFieldSymbol.IsExplicitlyNamedTupleElement.get -> bool
 Microsoft.CodeAnalysis.GeneratorExecutionContext.SyntaxContextReceiver.get -> Microsoft.CodeAnalysis.ISyntaxContextReceiver?
 Microsoft.CodeAnalysis.GeneratorInitializationContext.RegisterForSyntaxNotifications(Microsoft.CodeAnalysis.SyntaxContextReceiverCreator! receiverCreator) -> void
@@ -86,10 +87,10 @@ override Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>.DefaultVis
 override Microsoft.CodeAnalysis.Operations.OperationWalker<TArgument>.Visit(Microsoft.CodeAnalysis.IOperation? operation, TArgument argument) -> object?
 static Microsoft.CodeAnalysis.FileLinePositionSpan.operator !=(Microsoft.CodeAnalysis.FileLinePositionSpan left, Microsoft.CodeAnalysis.FileLinePositionSpan right) -> bool
 static Microsoft.CodeAnalysis.FileLinePositionSpan.operator ==(Microsoft.CodeAnalysis.FileLinePositionSpan left, Microsoft.CodeAnalysis.FileLinePositionSpan right) -> bool
+static Microsoft.CodeAnalysis.GeneratorExtensions.AsSourceGenerator(this Microsoft.CodeAnalysis.IIncrementalGenerator! incrementalGenerator) -> Microsoft.CodeAnalysis.ISourceGenerator!
+static Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(this Microsoft.CodeAnalysis.ISourceGenerator! generator) -> System.Type!
 static Microsoft.CodeAnalysis.LineMapping.operator !=(Microsoft.CodeAnalysis.LineMapping left, Microsoft.CodeAnalysis.LineMapping right) -> bool
 static Microsoft.CodeAnalysis.LineMapping.operator ==(Microsoft.CodeAnalysis.LineMapping left, Microsoft.CodeAnalysis.LineMapping right) -> bool
-static Microsoft.CodeAnalysis.GeneratorDriver.GetGeneratorType(Microsoft.CodeAnalysis.ISourceGenerator! generator) -> System.Type!
-static Microsoft.CodeAnalysis.GeneratorDriver.WrapGenerator(Microsoft.CodeAnalysis.IIncrementalGenerator! incrementalGenerator) -> Microsoft.CodeAnalysis.ISourceGenerator!
 static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Collect<TSource>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TSource> source) -> Microsoft.CodeAnalysis.IncrementalValueProvider<System.Collections.Immutable.ImmutableArray<TSource>>
 static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine<TLeft, TRight>(this Microsoft.CodeAnalysis.IncrementalValueProvider<TLeft> provider1, Microsoft.CodeAnalysis.IncrementalValueProvider<TRight> provider2) -> Microsoft.CodeAnalysis.IncrementalValueProvider<(TLeft Left, TRight Right)>
 static Microsoft.CodeAnalysis.IncrementalValueProviderExtensions.Combine<TLeft, TRight>(this Microsoft.CodeAnalysis.IncrementalValuesProvider<TLeft> provider1, Microsoft.CodeAnalysis.IncrementalValueProvider<TRight> provider2) -> Microsoft.CodeAnalysis.IncrementalValuesProvider<(TLeft Left, TRight Right)>