Fix issue where a write wasn't detected in make-readonly.

src/EditorFeatures/CSharpTest/MakeFieldReadonly/MakeFieldReadonlyTests.cs

@@ -6,6 +6,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.MakeFieldReadonly
@@ -779,5 +780,51 @@ partial struct MyClass { }",
 
     partial struct MyClass { }");
         }
+
+        [WorkItem(26262, "https://github.com/dotnet/roslyn/issues/26262")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
+        public async Task FieldAssignedInCtor_InParens()
+        {
+            await TestInRegularAndScriptAsync(
+@"class MyClass
+{
+    private int [|_goo|];
+    MyClass()
+    {
+        (_goo) = 0;
+    }
+}",
+@"class MyClass
+{
+    private readonly int _goo;
+    MyClass()
+    {
+        (_goo) = 0;
+    }
+}");
+        }
+
+        [WorkItem(26262, "https://github.com/dotnet/roslyn/issues/26262")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)]
+        public async Task FieldAssignedInCtor_QualifiedWithThis_InParens()
+        {
+            await TestInRegularAndScriptAsync(
+@"class MyClass
+{
+    private int [|_goo|];
+    MyClass()
+    {
+        (this._goo) = 0;
+    }
+}",
+@"class MyClass
+{
+    private readonly int _goo;
+    MyClass()
+    {
+        (this._goo) = 0;
+    }
+}");
+        }
     }
 }

src/EditorFeatures/VisualBasicTest/MakeFieldReadonly/MakeFieldReadonlyTests.vb

@@ -599,6 +599,30 @@ End Class")
 End Class")
         End Function
 
+        <WorkItem(26262, "https://github.com/dotnet/roslyn/issues/26262")>
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)>
+        Public Async Function CopyPassedAsByRefParameter() As Task
+            Await TestInRegularAndScriptAsync(
+"Class C
+    Private [|_goo|] As Integer = 0
+    Sub Goo()
+        ' Note: the parens cause a copy, so this is not an actual write into _goo
+        Bar((_goo))
+    End Sub
+    Sub Bar(ByRef value As Integer)
+    End Sub
+End Class",
+"Class C
+    Private ReadOnly _goo As Integer = 0
+    Sub Goo()
+        ' Note: the parens cause a copy, so this is not an actual write into _goo
+        Bar((_goo))
+    End Sub
+    Sub Bar(ByRef value As Integer)
+    End Sub
+End Class")
+        End Function
+
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsMakeFieldReadonly)>
         Public Async Function PassedAsByRefParameterInCtor() As Task
             Await TestInRegularAndScriptAsync(

src/Workspaces/CSharp/Portable/Extensions/ExpressionSyntaxExtensions.cs

@@ -325,13 +325,22 @@ public static bool IsInRefContext(this ExpressionSyntax expression)
         public static bool IsInInContext(this ExpressionSyntax expression)
             => (expression?.Parent as ArgumentSyntax)?.RefKindKeyword.Kind() == SyntaxKind.InKeyword;
 
-        public static bool IsOnlyWrittenTo(this ExpressionSyntax expression)
+        private static ExpressionSyntax GetExpressionToAnalyzeForWrites(ExpressionSyntax expression)
         {
             if (expression.IsRightSideOfDotOrArrow())
             {
                 expression = expression.Parent as ExpressionSyntax;
             }
 
+            expression = expression.WalkUpParentheses();
+
+            return expression;
+        }
+
+        public static bool IsOnlyWrittenTo(this ExpressionSyntax expression)
+        {
+            expression = GetExpressionToAnalyzeForWrites(expression);
+
             if (expression != null)
             {
                 if (expression.IsInOutContext())
@@ -356,24 +365,15 @@ public static bool IsOnlyWrittenTo(this ExpressionSyntax expression)
             return false;
         }
 
-        public static bool IsAttributeNamedArgumentIdentifier(this ExpressionSyntax expression)
-        {
-            var nameEquals = expression?.Parent as NameEqualsSyntax;
-            return nameEquals.IsParentKind(SyntaxKind.AttributeArgument);
-        }
-
         public static bool IsWrittenTo(this ExpressionSyntax expression)
         {
+            expression = GetExpressionToAnalyzeForWrites(expression);
+
             if (expression.IsOnlyWrittenTo())
             {
                 return true;
             }
 
-            if (expression.IsRightSideOfDotOrArrow())
-            {
-                expression = expression.Parent as ExpressionSyntax;
-            }
-
             if (expression.IsInRefContext())
             {
                 return true;
@@ -393,6 +393,12 @@ public static bool IsWrittenTo(this ExpressionSyntax expression)
             return false;
         }
 
+        public static bool IsAttributeNamedArgumentIdentifier(this ExpressionSyntax expression)
+        {
+            var nameEquals = expression?.Parent as NameEqualsSyntax;
+            return nameEquals.IsParentKind(SyntaxKind.AttributeArgument);
+        }
+
         public static bool IsOperandOfIncrementOrDecrementExpression(this ExpressionSyntax expression)
         {
             if (expression != null)