Fix code gen for some increment/compound assignment scenarios involving constrained calls. (#79293)

Fixes #79268

Author: AlekseyTs

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

@@ -274,7 +274,16 @@ BoundExpression rewriteAssignment(BoundExpression leftRead, BoundExpression righ
             Debug.Assert(rewrittenReceiver.Type is { });
             var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter;
 
-            var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind: variableRepresentsLocation ? RefKind.Ref : RefKind.None);
+            var receiverTemp = _factory.StoreToTemp(
+                rewrittenReceiver,
+                out assignmentToTemp,
+                refKind: variableRepresentsLocation ? RefKind.Ref : RefKind.None,
+                isKnownToReferToTempIfReferenceType: !variableRepresentsLocation || rewrittenReceiver.Type.IsValueType ||
+                                                     !CodeGenerator.HasHome(rewrittenReceiver,
+                                                                            CodeGenerator.AddressKind.Constrained,
+                                                                            _factory.CurrentFunction,
+                                                                            peVerifyCompatEnabled: false,
+                                                                            stackLocalsOpt: null));
             temps.Add(receiverTemp.LocalSymbol);
 
             if (!isRegularCompoundAssignment &&
@@ -476,7 +485,6 @@ private BoundIndexerAccess TransformIndexerAccessContinued(
 
         private BoundExpression TransformImplicitIndexerAccess(
             BoundImplicitIndexerAccess indexerAccess,
-            bool isRegularCompoundAssignment,
             ArrayBuilder<BoundExpression> stores,
             ArrayBuilder<LocalSymbol> temps,
             bool isDynamicAssignment)
@@ -486,19 +494,19 @@ private BoundExpression TransformImplicitIndexerAccess(
                 _compilation.GetWellKnownType(WellKnownType.System_Index),
                 TypeCompareKind.ConsiderEverything))
             {
-                return TransformIndexPatternIndexerAccess(indexerAccess, isRegularCompoundAssignment, stores, temps, isDynamicAssignment);
+                return TransformIndexPatternIndexerAccess(indexerAccess, stores, temps, isDynamicAssignment);
             }
 
             throw ExceptionUtilities.UnexpectedValue(indexerAccess.Argument.Type);
         }
 
-        private BoundExpression TransformIndexPatternIndexerAccess(BoundImplicitIndexerAccess implicitIndexerAccess, bool isRegularCompoundAssignment, ArrayBuilder<BoundExpression> stores, ArrayBuilder<LocalSymbol> temps, bool isDynamicAssignment)
+        private BoundExpression TransformIndexPatternIndexerAccess(BoundImplicitIndexerAccess implicitIndexerAccess, ArrayBuilder<BoundExpression> stores, ArrayBuilder<LocalSymbol> temps, bool isDynamicAssignment)
         {
             Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None);
             var access = GetUnderlyingIndexerOrSliceAccess(
                 implicitIndexerAccess,
                 isLeftOfAssignment: true,
-                isRegularAssignmentOrRegularCompoundAssignment: isRegularCompoundAssignment,
+                isRegularAssignment: false,
                 cacheAllArgumentsOnly: false,
                 stores, temps);
 
@@ -696,7 +704,7 @@ private BoundExpression TransformCompoundAssignmentLHS(BoundExpression originalL
 
                         if (implicitIndexerAccess.GetRefKind() == RefKind.None)
                         {
-                            return TransformImplicitIndexerAccess(implicitIndexerAccess, isRegularCompoundAssignment, stores, temps, isDynamicAssignment);
+                            return TransformImplicitIndexerAccess(implicitIndexerAccess, stores, temps, isDynamicAssignment);
                         }
                     }
                     break;
@@ -796,6 +804,7 @@ private BoundExpression TransformCompoundAssignmentLHS(BoundExpression originalL
 
                         if (eventAccess.EventSymbol.IsWindowsRuntimeEvent)
                         {
+                            Debug.Assert(!isRegularCompoundAssignment);
                             // This is a temporary object that will be rewritten away before the lowering completes.
                             return eventAccess.Update(TransformPropertyOrEventReceiver(eventAccess.EventSymbol, eventAccess.ReceiverOpt,
                                                                                        isRegularCompoundAssignment, stores, temps),

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

@@ -458,7 +458,7 @@ private BoundExpression VisitIndexPatternIndexerAccess(BoundImplicitIndexerAcces
 
             BoundExpression rewrittenIndexerAccess = GetUnderlyingIndexerOrSliceAccess(
                 node, isLeftOfAssignment,
-                isRegularAssignmentOrRegularCompoundAssignment: isLeftOfAssignment,
+                isRegularAssignment: isLeftOfAssignment,
                 cacheAllArgumentsOnly: false,
                 sideeffects, locals);
 
@@ -471,7 +471,7 @@ private BoundExpression VisitIndexPatternIndexerAccess(BoundImplicitIndexerAcces
         private BoundExpression GetUnderlyingIndexerOrSliceAccess(
             BoundImplicitIndexerAccess node,
             bool isLeftOfAssignment,
-            bool isRegularAssignmentOrRegularCompoundAssignment,
+            bool isRegularAssignment,
             bool cacheAllArgumentsOnly,
             ArrayBuilder<BoundExpression> sideeffects,
             ArrayBuilder<LocalSymbol> locals)
@@ -508,7 +508,7 @@ private BoundExpression GetUnderlyingIndexerOrSliceAccess(
                     if (receiverLocal.LocalSymbol.IsRef &&
                         CodeGenerator.IsPossibleReferenceTypeReceiverOfConstrainedCall(receiverLocal) &&
                         !CodeGenerator.ReceiverIsKnownToReferToTempIfReferenceType(receiverLocal) &&
-                        ((isLeftOfAssignment && !isRegularAssignmentOrRegularCompoundAssignment) ||
+                        ((isLeftOfAssignment && !isRegularAssignment) ||
                          !CodeGenerator.IsSafeToDereferenceReceiverRefAfterEvaluatingArguments(ImmutableArray.Create(makeOffsetInput))))
                     {
                         BoundAssignmentOperator? extraRefInitialization;

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

@@ -519,7 +519,7 @@ private void AddObjectInitializer(
                         rewrittenAccess = GetUnderlyingIndexerOrSliceAccess(
                             implicitIndexer,
                             isLeftOfAssignment: !isRhsNestedInitializer,
-                            isRegularAssignmentOrRegularCompoundAssignment: true,
+                            isRegularAssignment: true,
                             cacheAllArgumentsOnly: true,
                             result, temps);
 

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

@@ -582,7 +582,7 @@ public BoundExpression VisitBuiltInOrStaticIncrementOperator(BoundIncrementOpera
 
             // This will be filled in with the LHS that uses temporaries to prevent
             // double-evaluation of side effects.
-            BoundExpression transformedLHS = TransformCompoundAssignmentLHS(node.Operand, isRegularCompoundAssignment: true, tempInitializers, tempSymbols, isDynamic);
+            BoundExpression transformedLHS = TransformCompoundAssignmentLHS(node.Operand, isRegularCompoundAssignment: false, tempInitializers, tempSymbols, isDynamic);
             TypeSymbol? operandType = transformedLHS.Type; //type of the variable being incremented
             Debug.Assert(operandType is { });
             Debug.Assert(TypeSymbol.Equals(operandType, node.Type, TypeCompareKind.ConsiderEverything2));