Avoid optimizing away ref array access

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -659,6 +659,13 @@
 
     <Field Name="Expression" Type="BoundExpression"/>
     <Field Name="Indices" Type="ImmutableArray&lt;BoundExpression&gt;"/>
+
+    <!--
+      Ref array access has side effects (element type mismatch check)
+      so if it remains standalone (e.g., because the result is discarded)
+      we need to know if the original assignment was ref to emit it correctly.
+    -->
+    <Field Name="IsRef" Type="bool" />
   </Node>
 
   <!--

src/Compilers/CSharp/Portable/BoundTree/Constructors.cs

@@ -9,6 +9,25 @@
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
+    internal sealed partial class BoundArrayAccess
+    {
+        public BoundArrayAccess(
+            SyntaxNode syntax,
+            BoundExpression expression,
+            ImmutableArray<BoundExpression> indices,
+            TypeSymbol type,
+            bool hasErrors = false)
+            : this(syntax, expression, indices, isRef: false, type, hasErrors)
+        {
+        }
+
+        public BoundArrayAccess Update(BoundExpression expression, ImmutableArray<BoundExpression> indices, TypeSymbol type)
+            => this.Update(expression, indices, isRef: this.IsRef, type);
+
+        public BoundArrayAccess Update(bool isRef)
+            => this.Update(Expression, Indices, isRef: isRef, Type);
+    }
+
     internal sealed partial class BoundFieldAccess
     {
         public BoundFieldAccess(

src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs

@@ -1003,6 +1003,13 @@ internal static RefKind GetArgumentRefKind(ImmutableArray<BoundExpression> argum
 
         private void EmitArrayElementLoad(BoundArrayAccess arrayAccess, bool used)
         {
+            if (arrayAccess.IsRef)
+            {
+                EmitArrayElementAddress(arrayAccess, AddressKind.Writeable);
+                EmitPopIfUnused(used);
+                return;
+            }
+
             EmitExpression(arrayAccess.Expression, used: true);
             EmitArrayIndices(arrayAccess.Indices);
 

src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs

@@ -2186,6 +2186,11 @@ public override BoundNode VisitAssignmentOperator(BoundAssignmentOperator node)
 
             if (isLast)
             {
+                if (node.IsRef && right is BoundArrayAccess arrayAccess)
+                {
+                    return arrayAccess.Update(isRef: true);
+                }
+
                 // assigned local is not used later => just emit the Right
                 return right;
             }

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs

@@ -229,6 +229,11 @@ private BoundExpression MakeStaticAssignmentOperator(
 
                 case BoundKind.DiscardExpression:
                     {
+                        if (isRef && rewrittenRight is BoundArrayAccess arrayAccess)
+                        {
+                            return arrayAccess.Update(isRef: true);
+                        }
+
                         return rewrittenRight;
                     }